vantiv_lite 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5fc133b7d98fa13b255fa742c638a61b4967ab37
+  data.tar.gz: 667a4b905d9937d14f62abaefa30967dd9dd428f
+SHA512:
+  metadata.gz: db7cea41c6b32da8c25c827de18fa7f407b933dbfce1efd26e43f8da7da8cd86f6bb2e85d9e5b1e0f6b3a6631ad3045f4b1bbac9ffc32d570fc32c9042e57f6d
+  data.tar.gz: 78930183f9f3581eb86dc160c77439af517ba4c549a79a8659a7250d94a6ef792c4779f2e98110086de9d249a46a90fa1c5693b0739d6d791d9c0adedbdf489b

data/LICENSE.txt

@@ -0,0 +1,18 @@
+Copyright (c) 2018 Joshua Hansen
+
+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 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,223 @@
+# VantivLite
+
+## Overview
+
+This gem provides a simple interface for interacting with Vantiv's (WorldPay) LitleOnline eCommerce API. There's no real modeling. It's just a convenient way to configure your environment, send requests, and receive responses in hashes without all the mess of dealing with XML. As such, it should work with any API request available.
+
+### Why not just use [LitleOnline](https://github.com/Vantiv/litle-sdk-for-ruby), the official SDK?
+
+There are a number of reasons for creating this gem, despite the fact that an official Ruby implementation already exists. LitleOnline's code not particularly idiomatic Ruby. It's unlikely the developers are experienced Rubyists. That wouldn't be a show-stopper in and of itself, but the dependencies imposed by the gem are downright painful:
+
+1. [`libxml-ruby`](https://github.com/xml4r/libxml-ruby): A large library that requires an even larger native extension. Given the nature and size of the XML being generated, this is overkill unless you're already using `libxml-ruby` (and odds are you're not).
+2. [`xml-object`](https://github.com/burke/xml-object): In addition to being abandoned at this point, it has a dependency of [`ActiveSupport`](https://github.com/rails/rails/tree/master/activesupport)
+
+There are no requirements outside the standard library for this gem, although you can optionally use [Nokogiri](https://github.com/sparklemotion/nokogiri) or [Ox](https://github.com/ohler55/ox) for parsing/serializing XML.
+
+## Installation
+
+Pretty standard gem stuff.
+
+    $ gem install vantiv_lite
+
+When using [Bundler](https://bundler.io) or requiring this library in general, it's important to note that it will attempt to load it's XML add-ons by default If Nokogiri or Ox is already defined, it will use them in that order. Otherwise, it will use the default of REXML. The only consideration is that REXML will get required if neither optional library is already required.
+
+So, ensure your XML libs load first or just manually load it after the fact.
+
+## Configuration
+
+Out of the proverbial box, this should Just Work™ with Vantiv's (WorldPay) test environment using version 8.22 of the API. Obviously, when you go to production, that's probably not ideal. There are a number of ways to configure this gem.
+
+If you're integrating into a system that's using a single configuration---pretty common to just process credit cards for your institution---you can use a global configuration set either programmatically or via environment variables:
+
+**Note:** It's unlikely you're using version 8.22. In fact, versions can be a sticky issue with this API. Ensure you're using the version that has been assigned to you! You don't want to do all your testing in the default 8.22 only to find out you're on the latest when you move to `prelive`.
+
+### Programmatically
+
+```ruby
+  VantivLite.configure do
+    env          'sandbox'
+    merchant_id  'default'
+    password     'sandbox'
+    proxy_url    'http://user:passsword@proxy.internal:8888'
+    report_group 'Default Report Group'
+    username     'sandbox'
+    version      '8.22'
+    xml_lib      'REXML'
+  end
+```
+
+Note: All values displayed above are the default values, with the exception of `proxy_url` which is `nil` by default. (There's a good chance you'll need to set `proxy_url` in `prelive` and `postlive` environments since they are IP-whitelisted.)
+
+### `ENV`
+
+Prefix any configuration option with `vantiv_` and it will be automatically set:
+
+* `ENV['vantiv_env']`
+* `ENV['vantiv_merchant_id']`
+* `ENV['vantiv_password']`
+* `ENV['vantiv_proxy_url']`
+* `ENV['vantiv_report_group']`
+* `ENV['vantiv_username']`
+* `ENV['vantiv_version']`
+* `ENV['vantiv_xml_lib']`
+
+You can return the configuration set by the environment with `VantivLite.env_config` which might be useful in situations where you want multiple configurations modified from a default set by the environment.
+
+### Multiple Configurations
+
+If you're building a platform that allows multiple clients to plug into Vantiv's API with their own credentials, IDs, or whatever else you'll need to use different configuration options for each. This is done by creating `VantivLite::Config` objects and injecting them into requests. (The global default is used by default in new requests.)
+
+This can be done with an existing config:
+
+```ruby
+config = VantivLite.env_config
+new_config = config.with(username: 'user', password: 'password2')
+```
+
+Or by just creating a new one:
+
+```ruby
+# With a hash:
+
+config = VantivLite::Config.new(env: 'prelive' version: '11.1')
+
+# With DSL:
+
+config = VantivLite::Config.build
+  proxy_url 'http://proxy.internal:8888'
+  xml_lib 'Ox'
+end
+```
+
+## Making Requests
+
+A basic request can be made using `VantivLite.request`. This uses the global config and request objects:
+
+```ruby
+params = {
+  register_token_request: {
+    order_id: '50',
+    account_number: '4457119922390123'
+  }
+}
+
+response = VantivLite.request(params) # => #<VantivLite::Response>
+```
+
+This will return a `VantivLite::Response` which itself operates much like a hash:
+
+```ruby
+response.dig(:register_token_response, :litle_token) # => "1111222233330123"
+```
+
+For many simple transactions the `*_request` and `*_response` keys get a little tedious. So, this can be abreviated to the following:
+
+```ruby
+params = {
+  order_id: '50',
+  account_number: '4457119922390123'
+}
+
+response = VantivLite.register_token(params).dig(:litle_token) # => "1111222233330123"
+```
+
+There are shortcuts for the requests:
+
+  * `auth_reversal`
+  * `authorization`
+  * `capture`
+  * `credit`
+  * `register_token`
+  * `sale`
+  * `void`
+
+Note that the only transformation that is done is underscoring and symbolizing keys. No other mapping is done.
+
+### Requests With Multiple Configurations
+
+`VantiveLite.request` (and the various convenience versions) simply uses `Vantiv.default_request` which is just an instance of `VantivLite::Request`. The request object itself can be used similarly with the methods by invoking `#call`:
+
+```ruby
+params = {
+  register_token_request: {
+    order_id: '50',
+    account_number: '4457119922390123'
+  }
+}
+
+response = VantivLite::Request.new(custom_config).(params) # => #<VantivLite::Response>
+
+# Shortcut methods also work:
+
+params = {
+  order_id: '50',
+  account_number: '4457119922390123'
+}
+
+response = VantivLite::Request.new(custom_config).register_token(params)
+```
+
+### Elements and Attributes
+
+Obviously, XML doesn't map nice and neat to a hash and vice-versa. However, Vantiv's API doesn't make heavy use of attributes so, on serialization, certain keys are serialized into attributes and return hashes just merge everything together. For example, if you wanted to set an `id` attribute, you would do the following:
+
+```ruby
+params = {
+  register_token_request: {
+    id: 'abcdef',
+    order_id: '50',
+    account_number: '4457119922390123'
+  }
+}
+```
+
+See `VantivLite::XML::Serializer` for a list of defaults.
+
+### Order Matters
+
+This library does not use any sort of models and the mapping done is purely to rename keys into something more "Ruby-ish." Unfortunately, the API XML XSDs from Vantiv are relatively picky. Your hash keys should be in the same order they appear in the documentation.
+
+If you get an error like this:
+
+```
+VantivLite::Response::ServerError: Error validating xml data against the schema cvc-complex-type.2.4.a: Invalid content was found starting with element 'orderId'. One of '{"http://www.litle.com/schema":cardValidationNum}' is expected.
+```
+
+It probably means your keys are out of order.
+
+Yes, this could be solved by consuming the XSDs and validating requests or modeling every single object. However, the overhead probably isn't worth it and can require version specific changes. Developers are just going to wrap these lower level calls in their own objects anyway where order can be enforced as necessary.
+
+## Vantiv Environments
+
+Valid environments are:
+
+* `sandbox`
+* `prelive`
+* `postlive`
+
+This configures the API url. At the moment, that's really all it does.
+
+## Contributing
+
+### Issue Guidelines
+
+GitHub issues are for bugs, not support. As of right now, there is no official support for this gem. You can try reaching out to the author, [Joshua Hansen](mailto:joshua@epicbanality.com?subject=VantiveLite) if you're really stuck, but there's a pretty high chance that won't go anywhere at the moment or you'll get a response like this:
+
+> Hi. I'm super busy. It's nothing personal. Check the README first if you haven't already. If you don 't find your answer there, it's time to start reading the source. Have fun! Let me know if I screwed something up.
+
+### Pull Request Guidelines
+
+* Include tests with your PRs.
+* Run `rubocop` to ensure your style fits with the rest of the project.
+
+### Code of Conduct
+
+Be nice. After all, this is free code. I have a day job.
+
+## License
+
+See [`LICENSE.txt`](LICENSE.txt).
+
+## What if I stop maintaining this?
+
+The codebase isn't huge. If you opt to rely on this code and I die/get bored/find enlightenment you should be able to maintain it. Sadly, that's the only guarantee at the moment!

data/lib/vantiv_lite/config.rb

@@ -0,0 +1,98 @@
+# frozen-string-literal: true
+
+require 'net/http'
+require 'uri'
+
+module VantivLite
+  class Config
+    InvalidEnvironment = Class.new(StandardError)
+
+    ENVS = {
+      'sandbox' => URI('https://www.testvantivcnp.com/sandbox/communicator/online'),
+      'prelive' => URI('https://payments.vantivprelive.com/vap/communicator/online'),
+      'postlive' => URI('https://payments.vantivcnp.com/vap/communicator/online')
+    }.freeze
+
+    OPTS = %i[env merchant_id password proxy_url report_group username version xml_lib].freeze
+
+    class Builder
+      def self.call(&blk)
+        new.(&blk)
+      end
+
+      def initialize
+        @opts = {}
+      end
+
+      OPTS.each { |o| define_method(o) { |val| @opts[o] = val.to_s } }
+
+      def call(&blk)
+        instance_eval(&blk) if block_given?
+        Config.new(@opts)
+      end
+    end
+
+    def self.build(&blk)
+      Config::Builder.(&blk)
+    end
+
+    attr_reader :proxy_uri, :sandbox, :uri
+    alias sandbox? sandbox
+
+    def initialize(**opts)
+      @opts = opts.each_with_object({}) { |(k, v), h| OPTS.include?(k = k.to_sym) && h[k] = v.to_s }
+      defaults!
+      load_xml_lib
+      env_valid?
+      proxy_uri!
+      @uri = ENVS[@opts[:env]]
+    end
+
+    def opts
+      @opts.dup
+    end
+
+    def proxy_args
+      @proxy_uri ? [@proxy_uri.host, @proxy_uri.port, @proxy_uri.user, @proxy_uri.password] : []
+    end
+
+    def with(**opts)
+      new(@opts.merge(opts))
+    end
+
+    OPTS.each { |o| define_method(o) { @opts[o] } }
+
+    private
+
+    def default_xml_lib
+      return 'Ox' if defined?(::Ox)
+      return 'Nokogiri' if defined?(::Nokogiri)
+      'REXML'
+    end
+
+    def defaults!
+      @opts[:env] ||= 'sandbox'
+      @opts[:report_group] ||= 'Default Report Group'
+      @opts[:version] ||= '8.22'
+      @opts[:xml_lib] ||= default_xml_lib
+      return unless (@sandbox = (opts[:env] == 'sandbox'))
+      @opts[:merchant_id] ||= 'default'
+      @opts[:password] ||= 'sandbox'
+      @opts[:username] ||= 'sandbox'
+    end
+
+    def env_valid?
+      raise InvalidEnvironment, %(:env must be set to one of: "#{ENVS.keys.join('", "')}") unless
+        ENVS.key?(@opts[:env])
+    end
+
+    def load_xml_lib
+      require "vantiv_lite/xml/#{@opts[:xml_lib].downcase}"
+    end
+
+    def proxy_uri!
+      return unless (url = @opts['proxy_url'] || ENV['HTTP_PROXY'] || ENV['http_proxy'])
+      @proxy_uri = URI(url)
+    end
+  end
+end

data/lib/vantiv_lite/request.rb

@@ -0,0 +1,92 @@
+# frozen-string-literal: true
+
+require 'securerandom'
+require 'vantiv_lite/response'
+require 'vantiv_lite/xml'
+
+module VantivLite
+  TRANSACTIONS = %w[
+    auth_reversal
+    authorization
+    capture
+    credit
+    register_token
+    sale
+    void
+  ].freeze
+
+  class Request
+    InvalidConfig = Class.new(StandardError)
+    ResponseError = Class.new(StandardError)
+
+    attr_reader :config, :http, :serializer
+
+    def initialize(config = VantivLite.default_config, http: nil, serializer: nil)
+      raise InvalidConfig, 'invalid or missing config' unless config.is_a?(Config)
+      @config = config
+      @http = http || _http
+      @parser = XML.parser_with(config.xml_lib)
+      @serializer = serializer || XML.serializer_with(config.xml_lib)
+    end
+
+    def call(request_hash, *dig_keys)
+      Response.new(post(serializer.(format_request(request_hash))), *dig_keys, parser: @parser)
+    end
+
+    def post(xml)
+      http.start { |h| h.request(post_request(xml)) }
+    end
+
+    TRANSACTIONS.each do |t|
+      define_method(t) { |hash| call({ :"#{t}_request" => hash }, :"#{t}_response") }
+    end
+
+    private
+
+    def _http
+      Net::HTTP.new(config.uri.host, config.uri.port, *config.proxy_args).tap do |h|
+        h.use_ssl = true if config.uri.scheme == 'https'
+      end
+    end
+
+    def default_attributes_with(hash)
+      hash['id'] ||= SecureRandom.hex(12)
+      hash['reportGroup'] ||= config.report_group
+      hash
+    end
+
+    def format_request(request_hash)
+      {
+        'litleOnlineRequest' => {
+          'xmlns' => 'http://www.litle.com/schema',
+          'version' => config.version,
+          'merchantId' => config.merchant_id,
+          'authentication' => { 'user' => config.username, 'password' => config.password }
+        }.merge(insert_default_attributes(lower_camelize_keys(request_hash)))
+      }
+    end
+
+    def insert_default_attributes(request_hash)
+      request_hash.each_with_object({}) do |(k, obj), h|
+        h[k] = XML.hash_or_array(obj) { |o| default_attributes_with(o) }
+      end
+    end
+
+    def lower_camelize_keys(hash)
+      XML.transform_keys(hash) do |k|
+        if k.is_a?(String)
+          k
+        else
+          k.to_s.gsub(/_[a-z]/i) { |m| m[1].upcase }.tap { |s| s[0] = s[0].downcase }
+        end
+      end
+    end
+
+    def post_request(xml)
+      Net::HTTP::Post.new(config.uri.path).tap do |r|
+        r['Content-Type'] ||= 'text/xml; charset=UTF-8'
+        r.body = xml
+      end
+    end
+  end
+end

data/lib/vantiv_lite/response.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+
+require 'vantiv_lite/xml'
+
+module VantivLite
+  class Response
+    ServerError = Class.new(StandardError)
+    ROOT_KEY = :litle_online_response
+
+    module Refinements
+      [Array, Hash].each do |klass|
+        next if klass.public_instance_methods.include?(:dig)
+        refine klass do
+          def dig(key, *next_keys)
+            Dig.(self, key, *next_keys)
+          end
+        end
+      end
+    end
+
+    using Refinements
+
+    Dig = lambda do |obj, key, *next_keys|
+      begin
+        next_obj = obj[key]
+        next_obj.nil? || next_keys.empty? ? next_obj : next_obj.dig(*next_keys)
+      rescue NoMethodError
+        raise TypeError, "#{next_obj.class.name} does not have #dig method"
+      end
+    end
+
+    include Enumerable
+
+    attr_reader :to_h
+    alias to_hash to_h
+
+    def initialize(http_response, *dig_keys, parser:)
+      http_ok?(http_response)
+      @to_h = response_hash_with(parser.(http_response.body), dig_keys)
+    end
+
+    def [](key)
+      @to_h[key]
+    end
+
+    def dig(key, *next_keys)
+      Dig.(@to_h, key, *next_keys)
+    end
+
+    def each(*args, &blk)
+      @to_h.each(*args, &blk)
+    end
+
+    private
+
+    def http_ok?(http_response)
+      raise ServerError, "server responded with #{http_response.code} instead of 200" unless
+        http_response.code == '200'
+    end
+
+    def response_hash_with(response_hash, dig_keys)
+      response_hash = underscore_symbolize_keys(response_hash)
+      raise ServerError, "missing root :#{ROOT_KEY}" unless (root_hash = response_hash[ROOT_KEY])
+      raise ServerError, root_hash[:message] unless root_hash[:response] == '0'
+      dig_keys.any? ? root_hash.dig(*dig_keys) : root_hash
+    end
+
+    def underscore_symbolize_keys(hash)
+      XML.transform_keys(hash) { |k| k.gsub(/[A-Z]/) { |m| "_#{m.downcase}" }.to_sym }
+    end
+  end
+end

data/lib/vantiv_lite/version.rb

@@ -0,0 +1,12 @@
+# frozen-string-literal: true
+
+module VantivLite
+  MAJOR = 0
+  MINOR = 1
+  TINY  = 0
+  VERSION = [MAJOR, MINOR, TINY].join('.').freeze
+
+  def self.version
+    VERSION
+  end
+end

data/lib/vantiv_lite/xml/nokogiri.rb

@@ -0,0 +1,46 @@
+# frozen-string-literal: true
+
+require 'nokogiri'
+require 'vantiv_lite/xml'
+
+module VantivLite
+  module XML
+    module Nokogiri
+      class Parser
+        include XML::Parser
+
+        private
+
+        def root(xml)
+          ::Nokogiri::XML(xml) { |c| c.options = ::Nokogiri::XML::ParseOptions::NOBLANKS }.root
+        end
+
+        def value_with!(element)
+          return element.text if element.attributes.empty? && element.elements.empty?
+          element.to_h.merge(hash_with(*element.elements))
+        end
+      end
+
+      class Serializer
+        include XML::Serializer
+
+        def call(hash)
+          ::Nokogiri::XML::Document.new.tap { |d| add_xml_elements!(d, hash) }.to_s
+        end
+
+        private
+
+        def attributes_or_elements!(parent, key, value)
+          return parent[key] = text_with(value) if attributes.include?(key)
+          e = ::Nokogiri::XML::Element.new(key, parent)
+          parent.add_child(e)
+          add_xml_elements!(e, value)
+        end
+
+        def insert_text!(element, text)
+          element.add_child(text_with(text))
+        end
+      end
+    end
+  end
+end

data/lib/vantiv_lite/xml/ox.rb

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+
+require 'ox'
+require 'vantiv_lite/xml'
+
+module VantivLite
+  module XML
+    module Ox
+      class Parser
+        include XML::Parser
+
+        private
+
+        def root(xml)
+          ::Ox.load(xml, symbolize_keys: false)
+        end
+
+        def value_with!(node)
+          node.text ? node.text : node.attributes.merge(hash_with(*node.nodes))
+        end
+      end
+
+      class Serializer
+        include XML::Serializer
+
+        def call(hash)
+          ::Ox.dump(add_xml_elements!(::Ox::Document.new(version: '1.0'), hash))
+        end
+
+        private
+
+        def attributes_or_elements!(parent, key, value)
+          return parent[key] = text_with(value) if attributes.include?(key)
+          e = ::Ox::Element.new(key)
+          parent << e
+          add_xml_elements!(e, value)
+        end
+
+        def insert_text!(node, text)
+          node << text_with(text)
+        end
+      end
+    end
+  end
+end

data/lib/vantiv_lite/xml/parser.rb

@@ -0,0 +1,27 @@
+# frozen-string-literal: true
+
+module VantivLite
+  module XML
+    module Parser
+      def call(xml)
+        hash_with(root(xml))
+      end
+
+      private
+
+      def hash_with(*nodes)
+        nodes.each_with_object({}) do |n, h|
+          inject_or_merge!(h, n.name, value_with!(n))
+        end
+      end
+
+      def inject_or_merge!(hash, key, value)
+        if hash.key?(key)
+          cv = hash[key]
+          value = cv.is_a?(Array) ? cv.push(value) : [cv, value]
+        end
+        hash[key] = value
+      end
+    end
+  end
+end

data/lib/vantiv_lite/xml/rexml.rb

@@ -0,0 +1,55 @@
+# frozen-string-literal: true
+
+require 'rexml/document'
+require 'vantiv_lite/xml'
+
+module VantivLite
+  module XML
+    module REXML
+      class Parser
+        include XML::Parser
+
+        private
+
+        def attribute_hash(element)
+          element.attributes.each_with_object({}) { |(k, v), h| h[k] = v.to_s }
+        end
+
+        def root(xml)
+          ::REXML::Document.new(xml).root
+        end
+
+        def value_with!(element)
+          children = element.elements.to_a
+          return element.text if element.attributes.empty? && children.empty?
+          attribute_hash(element).merge(hash_with(*children))
+        end
+      end
+
+      class Serializer
+        include XML::Serializer
+
+        def call(hash)
+          # NOTE: This forces attributes to be delimited with double quotes. Despite the fact that
+          # the Litle API returns single-quoted responses, requests with single-quoted attributes
+          # will yield an internal server error.
+          ::REXML::Document.new(nil, attribute_quote: :quote).tap do |d|
+            d.add(::REXML::XMLDecl.new)
+            add_xml_elements!(d, hash)
+          end.to_s
+        end
+
+        private
+
+        def attributes_or_elements!(parent, key, value)
+          return parent.add_attribute(key, text_with(value)) if attributes.include?(key)
+          add_xml_elements!(::REXML::Element.new(key, parent, parent.context), value)
+        end
+
+        def insert_text!(element, text)
+          element.add_text(text_with(text))
+        end
+      end
+    end
+  end
+end

data/lib/vantiv_lite/xml/serializer.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+
+module VantivLite
+  module XML
+    module Serializer
+      ATTRIBUTES = %w[id merchantId reportGroup version xmlns].freeze
+
+      @@type_coercions = {}
+      def self.coerce(type, obj = nil, &blk)
+        raise TypeError, '`type` must be a `Class`' unless type.is_a?(Class)
+        obj ||= blk
+        raise TypeError, '`obj` must respond to `call`' unless obj.respond_to?(:call)
+        @@type_coercions[type] = obj
+      end
+
+      attr_reader :attributes
+
+      def initialize(attributes: ATTRIBUTES)
+        @attributes = attributes
+      end
+
+      private
+
+      def add_xml_elements!(parent, obj)
+        case obj
+        when Hash
+          obj.each { |k, v| attributes_or_elements!(parent, k, v) }
+        when Array
+          obj.each { |v| add_xml_elements!(parent, v) }
+        else
+          insert_text!(parent, obj)
+        end
+        parent
+      end
+
+      def text_with(obj)
+        (callable = @@type_coercions[obj.class]) ? callable.call(obj) : obj.to_s
+      end
+    end
+  end
+end

data/lib/vantiv_lite/xml.rb

@@ -0,0 +1,36 @@
+# frozen-string-literal: true
+
+require 'vantiv_lite/xml/parser'
+require 'vantiv_lite/xml/serializer'
+
+module VantivLite
+  module XML
+    class << self
+      def hash_or_array(obj)
+        case obj
+        when Hash
+          yield(obj)
+        when Array
+          obj.map { |o| yield(o) }
+        else
+          obj
+        end
+      end
+
+      def parser_with(name)
+        const_get(name)::Parser.new
+      end
+
+      def serializer_with(name, attributes: Serializer::ATTRIBUTES)
+        const_get(name)::Serializer.new(attributes: attributes)
+      end
+
+      def transform_keys(hash, &blk)
+        return hash unless hash.is_a?(Hash)
+        hash.each_with_object({}) do |(k, obj), h|
+          h[yield(k)] = XML.hash_or_array(obj) { |o| transform_keys(o, &blk) }
+        end
+      end
+    end
+  end
+end

data/lib/vantiv_lite.rb

@@ -0,0 +1,30 @@
+# frozen-string-literal: true
+
+require 'vantiv_lite/config'
+require 'vantiv_lite/request'
+
+module VantivLite
+  class << self
+    attr_reader :default_config, :default_request
+
+    def configure(config = env_config, &blk)
+      @default_config = block_given? ? Config.build(&blk) : Config.new(config)
+      @default_request = Request.new(@default_config)
+    end
+
+    def env_config
+      Config::OPTS.each_with_object({}) do |k, h|
+        env_key = "vaniv_#{k}"
+        h[k] = ENV[env_key] if ENV.key?(env_key)
+      end
+    end
+
+    def request(request_hash)
+      default_request.(request_hash)
+    end
+    alias call request
+
+    TRANSACTIONS.each { |t| define_method(t) { |hash| default_request.public_send(t, hash) } }
+  end
+  configure
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: vantiv_lite
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joshua
+- Hansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.56'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.56'
+description: A Simplified Vanitiv/WorldPay (LitleOnline) API Library
+email:
+- joshua@epicbanality.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/vantiv_lite.rb
+- lib/vantiv_lite/config.rb
+- lib/vantiv_lite/request.rb
+- lib/vantiv_lite/response.rb
+- lib/vantiv_lite/version.rb
+- lib/vantiv_lite/xml.rb
+- lib/vantiv_lite/xml/nokogiri.rb
+- lib/vantiv_lite/xml/ox.rb
+- lib/vantiv_lite/xml/parser.rb
+- lib/vantiv_lite/xml/rexml.rb
+- lib/vantiv_lite/xml/serializer.rb
+homepage: https://github.com/binarypaladin/vantiv_lite
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.4
+signing_key: 
+specification_version: 4
+summary: A Simplified Vanitiv/WorldPay (LitleOnline) API Library
+test_files: []