genesis_ruby 0.1.0

data/lib/genesis_ruby/errors/object_formatter_error.rb

@@ -0,0 +1,14 @@
+require 'genesis_ruby/errors/error'
+
+module GenesisRuby
+  # Invalid Argument Custom Error
+  class ObjectFormatterError < Error
+
+    def custom_message
+      return 'Invalid format given!' unless @message
+
+      @message
+    end
+
+  end
+end

data/lib/genesis_ruby/errors/parameter_error.rb

@@ -0,0 +1,12 @@
+require 'genesis_ruby/errors/error'
+
+module GenesisRuby
+  # Invalid Argument Custom Error
+  class ParameterError < Error
+
+    def custom_message
+      "Please verify the following transaction parameters:\n#{@message}"
+    end
+
+  end
+end

data/lib/genesis_ruby/errors/parser_error.rb

@@ -0,0 +1,14 @@
+require 'genesis_ruby/errors/error'
+
+module GenesisRuby
+  # Invalid Argument Custom Error
+  class ParserError < Error
+
+    def custom_message
+      return 'Unknown error during parsing the response!' unless @message
+
+      @message
+    end
+
+  end
+end

data/lib/genesis_ruby/errors/response_error.rb

@@ -0,0 +1,14 @@
+require 'genesis_ruby/errors/error'
+
+module GenesisRuby
+  # Response Custom Error
+  class ResponseError < Error
+
+    def custom_message
+      return 'Invalid/Unexpected format given! ' unless @message
+
+      @message
+    end
+
+  end
+end

data/lib/genesis_ruby/network/adapter/base_adapter.rb

@@ -0,0 +1,31 @@
+module GenesisRuby
+  module Network
+    module Adapter
+      # Base Network Adapter Class
+      class BaseAdapter
+
+        # Response body is plain string received from the server
+        # Response header is hash with the received headers from the server
+        attr_accessor :response_body, :response_headers
+
+        # Retrieve HTTP Response Status Code
+        def status
+          raise NotImplementedError, 'Status method must be implemented'
+        end
+
+        # Prepare the Request
+        # Return the adapter library request object
+        def prepare_request(data)
+          raise NotImplementedError, 'Prepare Request Body method must be implemented'
+        end
+
+        # Execute the request
+        # Return the adapter library response object
+        def execute
+          raise NotImplementedError, 'Execute method must be implemented'
+        end
+
+      end
+    end
+  end
+end

data/lib/genesis_ruby/network/adapter/net_http_adapter.rb

@@ -0,0 +1,92 @@
+require 'genesis_ruby/network/adapter/base_adapter'
+require 'genesis_ruby/errors/network_error'
+require 'net/http'
+
+module GenesisRuby
+  module Network
+    module Adapter
+      # Net-HTTP Adapter implementation
+      class NetHttpAdapter < BaseAdapter
+
+        # HTTP Response Status Code
+        def status
+          @response&.code
+        end
+
+        # Prepare the request from the given data
+        def prepare_request(data)
+          @request_data = data
+          @uri          = parse_uri
+          # Force connection re-creation
+          @request      = Net::HTTP.start(@uri.hostname ||= '', ssl_options)
+        end
+
+        # Send the request
+        def execute
+          raise NetworkError, 'Request is not initialized' unless @request
+
+          begin
+            # TODO: Use GenesisRuby::Api::Request::METHOD_XXX constants for sending GET and PUT request_data.type
+            @response = @request.post(path, request_data.body, headers)
+          rescue StandardError => e
+            raise NetworkError, "Network error raised by #{e.class.name}: #{e.message}"
+          ensure
+            # Close the request
+            @request.finish
+          end
+        end
+
+        # Response body
+        def response_body
+          @response_body ||= @response ? @response.body : ''
+        end
+
+        # Response headers
+        def response_headers
+          @response_headers ||= @response ? @response.each_header.to_h : {}
+        end
+
+        private
+
+        attr_reader :uri, :request, :response, :request_data
+
+        # Path accessor that secure always string return value
+        def path
+          path = @uri&.path
+
+          path.empty? ? '/' : path
+        end
+
+        # Override URI parsing errors
+        def parse_uri
+          URI.parse(request_data.url)
+        rescue URI::Error => e
+          raise NetworkError, "Error during URL parsing: #{e.message}"
+        end
+
+        # Define SSL requirements
+        def ssl_options
+          {
+            use_ssl:         true,
+            verify_mode:     OpenSSL::SSL::VERIFY_PEER,
+            verify_depth:    10,
+            verify_hostname: true,
+            read_timeout:    request_data.timeout,
+            min_version:     OpenSSL::SSL::TLS1_VERSION
+          }
+        end
+
+        # Define Headers
+        def headers
+          {
+            'Content-Type'   => request_data.format,
+            'Content-Length' => request_data.body&.length.to_s,
+            'Authorization'  => "Basic #{request_data.user_login}",
+            'User-Agent'     => request_data.user_agent
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/genesis_ruby/network/base_network.rb

@@ -0,0 +1,83 @@
+require 'genesis_ruby/errors/invalid_argument_error'
+require 'genesis_ruby/utils/options/network_adapter_config'
+require 'base64'
+
+module GenesisRuby
+  module Network
+    # Base Network factory class
+    class BaseNetwork
+
+      XML_HEADER  = 'application/xml'.freeze
+      JSON_HEADER = 'application/json'.freeze
+
+      # Base constructor
+      def initialize(configuration)
+        @context                = factory
+        @configuration          = configuration
+        @network_adapter_config = GenesisRuby::Utils::Options::NetworkAdapterConfig.new
+      end
+
+      # Return the Response Body
+      def response_body
+        @context.response_body
+      end
+
+      # Return the Response Headers
+      def response_headers
+        @context.response_headers
+      end
+
+      # Send the request
+      def send_request
+        @context.execute
+      end
+
+      # Initialize the Adapter
+      def init_api_data(request)
+        @context.prepare_request(adapter_data_mapper(request))
+      end
+
+      # Every child defines is XML Response Type
+      def xml?
+        raise NotImplementedError, 'Is XML method must be implemented'
+      end
+
+      # Every child defines is JSON Response Type
+      def json?
+        raise NotImplementedError, 'Is JSON method must be implemented'
+      end
+
+      protected
+
+      # GenesisRuby::Configuration, Adapter Context, Network Adapter Config mapper
+      attr_reader :configuration, :context, :network_adapter_config
+
+      # Every child override and initialize its instance
+      def factory
+        raise NotImplementedError, 'Factory method must be implemented'
+      end
+
+      # Map the Request to the Network Adapter object
+      def adapter_data_mapper(request)
+        network_adapter_config.map_from_request(request).merge(
+          {
+            user_login: build_user_login,
+            user_agent: network_user_agent,
+            timeout:    configuration.timeout
+          }
+        )
+      end
+
+      # Build the User login string used for the Authorization Header
+      def build_user_login
+        Base64.urlsafe_encode64("#{configuration.username}:#{configuration.password}")
+      end
+
+      # The default user agent for every Network
+      def network_user_agent
+        "Genesis Ruby Client #{GenesisRuby::VERSION}. Network: #{self.class.name}"
+      end
+
+    end
+  end
+end

data/lib/genesis_ruby/network/net_http.rb

@@ -0,0 +1,28 @@
+require 'genesis_ruby/network/base_network'
+require 'genesis_ruby/network/adapter/net_http_adapter'
+
+module GenesisRuby
+  module Network
+    # Net HTTP Network module
+    class NetHttp < BaseNetwork
+
+      # JSON Response Type
+      def xml?
+        response_headers['content-type'].downcase.include?(BaseNetwork::XML_HEADER)
+      end
+
+      # JSON Response Type
+      def json?
+        response_headers['content-type'].downcase.include?(BaseNetwork::JSON_HEADER)
+      end
+
+      protected
+
+      # Adapter Initialization
+      def factory
+        GenesisRuby::Network::Adapter::NetHttpAdapter.new
+      end
+
+    end
+  end
+end

data/lib/genesis_ruby/parser.rb

@@ -0,0 +1,44 @@
+require 'genesis_ruby/parsers/xml'
+require 'genesis_ruby/errors/parser_error'
+
+module GenesisRuby
+  # Parser handler
+  class Parser
+
+    # XML Parser
+    XML  = 'xml'.freeze
+
+    # JSON Parser
+    JSON = 'json'.freeze
+
+    # Initialize the Parser Interface based on the Response requirements
+    def initialize(response_interface)
+      case response_interface
+      when XML
+        @parser_context = GenesisRuby::Parsers::Xml.new
+      else
+        raise GenesisRuby::ParserError, 'Invalid Parser interface!'
+      end
+    end
+
+    # Parsed document
+    def structure
+      parser_context.structure
+    end
+
+    # Parse tree-structure into Builder document
+    def parse_document(document)
+      parser_context.parse_document(document)
+    end
+
+    # Indicates that the Root element will not be included in the generated Object
+    def skip_root_node
+      parser_context.skip_root_node
+    end
+
+    private
+
+    attr_accessor :parser_context
+
+  end
+end

data/lib/genesis_ruby/parsers/base.rb

@@ -0,0 +1,25 @@
+module GenesisRuby
+  module Parsers
+    # Contract for every parser abstraction
+    class Base
+
+      attr_reader :structure, :root_node_skipped
+
+      def initialize
+        @structure         = {}
+        @root_node_skipped = false
+      end
+
+      # Parse given document to Hash Structuce
+      def parse_document(document)
+        raise NotImplementedError, 'Parse Document must be implemented'
+      end
+
+      # Indicates that the Root element will not be included in the generated Object
+      def skip_root_node
+        @root_node_skipped = true
+      end
+
+    end
+  end
+end

data/lib/genesis_ruby/parsers/xml.rb

@@ -0,0 +1,120 @@
+require 'genesis_ruby/parsers/base'
+require 'nokogiri'
+
+module GenesisRuby
+  module Parsers
+    # XML Document Parser
+    class Xml < Base
+
+      def parse_document(document)
+        load_document(document)
+
+        @structure = if root_node_skipped
+                       collect_nodes(@document.root)
+                     else
+                       { @document.root.name.to_sym => collect_attributes(@document.root).merge(
+                         collect_nodes(@document.root)
+                       ) }
+                     end
+      end
+
+      private
+
+      attr_reader :document
+
+      # Nokogiri::XML.parse
+      def load_document(document)
+        @document  = Nokogiri::XML.parse document, &:strict
+      rescue Nokogiri::SyntaxError
+        raise ParserError, 'Given Document is invalid'
+      end
+
+      # Loop the given Nokogiri::XML::Document
+      def collect_nodes(nodes, tree = {})
+        nodes.children.each do |child|
+          next if skip_element?(child)
+
+          tree[child.name.to_sym] = [tree[child.name.to_sym]] if duplicated_keys?(tree, child.name.to_sym)
+
+          process_node(child, tree)
+        end
+
+        tree
+      end
+
+      # Process every node by checking the type of the given tree and take decision for further processing
+      def process_node(node, tree)
+        key = node.name.to_sym
+
+        # The node has children of type Nokogiri::XML::Node.element?
+        return tree[key] = collect_children(node, tree) if children_elements?(node)
+
+        # The node is Element type and the tree has duplicated keys
+        return tree[key].push format_element(node) if tree[key].is_a? Array
+
+        # Simple Element formatting
+        tree[key] = format_element(node)
+      end
+
+      # Handle Nokogiri::XML::Element and take decision for further processing
+      def collect_children(child, tree)
+        key       = child.name.to_sym
+        tree[key] = collect_attributes(child) unless tree[key]
+
+        case tree[key]
+        when Array
+          tree[key].push collect_attributes(child).merge collect_nodes(child, {})
+        when Hash
+          collect_nodes(child, tree[key])
+        end
+      end
+
+      # Format Nokogiri::XML::Element element
+      def format_element(element)
+        attributes = collect_attributes(element)
+
+        return element.content.to_s if attributes.empty? && !children_elements?(element)
+
+        attributes.merge(
+          element.content.to_s.empty? ? {} : { element.name.to_sym => element.content.to_s }
+        )
+      end
+
+      # Collect attributes of the given Nokogiri::XML::Node
+      def collect_attributes(element)
+        attributes = {}
+
+        element.attributes.each_value { |attribute| attributes.merge! format_attributes attribute }
+
+        attributes
+      end
+
+      # Format Nokogiri::XML:Element.attributes
+      def format_attributes(element)
+        { element.name.to_sym => element.value.to_s }
+      end
+
+      # Check if the given tree already has definition of the given key
+      def duplicated_keys?(tree, key)
+        tree.is_a?(Hash) && tree.key?(key) && !tree[key].is_a?(Array)
+      end
+
+      # Check if the given element should be skipped
+      def skip_element?(element)
+        blank_element?(element) || element.comment? || element.cdata? || element.xml? || element.html?
+      end
+
+      # Check if the given Nokogiri::XML::Node has blank element (ex. "\n   ")
+      # Doesn't remove <element/> as Genesis has such output (ex Chargeback cnn)
+      def blank_element?(element)
+        element.text? && element.content.strip.empty?
+      end
+
+      # Check if the given element has at least one child with Nokogiri::XML::Node.children of Element type
+      def children_elements?(element)
+        !element.children.find(&:element?).nil?
+      end
+
+    end
+  end
+end

data/lib/genesis_ruby/utils/common.rb

@@ -0,0 +1,108 @@
+require 'uri'
+require 'date'
+
+module GenesisRuby
+  module Utils
+    # Common Utils used all across the project
+    class Common
+
+      class << self
+
+        # Deep compact over the given nested structure
+        def deep_compact!(structure)
+          structure.each do |element_key, element_value|
+            deep_compact!(element_key) if element_key.is_a? Hash
+            deep_compact!(element_value) if element_value.is_a?(Hash) || element_value.is_a?(Array)
+          end
+
+          compact_array! structure
+          compact_hash! structure
+        end
+
+        # Compact over given Array
+        def compact_array!(structure)
+          return unless structure.is_a? Array
+
+          structure.reject! do |element|
+            element.is_a?(Array) || element.is_a?(Hash) ? element.empty? : element.nil?
+          end
+        end
+
+        # Compact over given Hash
+        def compact_hash!(structure)
+          return unless structure.is_a? Hash
+
+          structure.reject! do |_key, value|
+            value.is_a?(Array) || value.is_a?(Hash) ? value.empty? : value.nil?
+          end
+        end
+
+        # Deep compact empty over the given nested hash
+        def deep_compact_empty!(structure)
+          structure.each do |element_key, element_value|
+            deep_compact_empty!(element_key) if element_key.is_a? Hash
+            deep_compact_empty!(element_value) if element_value.is_a?(Hash) || element_value.is_a?(Array)
+          end
+
+          empty_compact_array!(structure)
+          empty_compact_hash!(structure)
+        end
+
+        # Remove empty elements from an Array
+        def empty_compact_array!(structure)
+          return unless structure.is_a? Array
+
+          structure.reject! do |element|
+            element.is_a?(Array) || element.is_a?(Hash) || element.is_a?(String) ? element.empty? : element.nil?
+          end
+        end
+
+        # Remove empty elements from an Hash
+        def empty_compact_hash!(structure)
+          return unless structure.is_a? Hash
+
+          structure.reject! do |_key, value|
+            value.is_a?(Array) || value.is_a?(Hash) || value.is_a?(String) ? value.empty? : value.nil?
+          end
+        end
+
+        # Retrieve all constant values defined in the given module or class
+        def constant_values(reference)
+          constant_values = []
+
+          reference.constants(false).each do |constant_value|
+            value = reference.const_get constant_value
+
+            constant_values.push value unless value.is_a?(Class) || value.is_a?(Module)
+          end
+
+          constant_values.sort
+        end
+
+        # Validates URL
+        def valid_url?(url)
+          uri = URI.parse(url)
+
+          %w(http https).include?(uri.scheme) && !uri.host.nil? && !uri.host.to_s.empty?
+        rescue StandardError
+          false
+        end
+
+        # Parses string to DateTime
+        def parse_date(date, formats)
+          parsed_date = nil
+
+          formats.each do |format|
+            return Date.strptime(date, format)
+          rescue StandardError
+            parsed_date = nil
+          end
+
+          parsed_date
+        end
+
+      end
+
+    end
+  end
+end

data/lib/genesis_ruby/utils/formatters/base.rb

@@ -0,0 +1,40 @@
+module GenesisRuby
+  module Utils
+    module Formatters
+      # Object Formatter Contract
+      # ObjectFormatter iterate over each formatter with the given structure
+      class Base
+
+        # The Response keys that the formatter will be applied to
+        def formatting_keys
+          []
+        end
+
+        # The keys required for formatting the specific response key
+        def required_keys
+          []
+        end
+
+        # Format the given Response Key value
+        def format_key(*_args)
+          raise NotImplementedError, 'Format method is not implemented'
+        end
+
+        # Collect required key's values requires for the Response Object formatting
+        # Ex. Amount to Major requires Currency
+        def collect_required_key_values(response_object)
+          required_key_values = []
+
+          required_keys.each do |required_key|
+            next unless response_object.include?(required_key.to_sym)
+
+            required_key_values.push response_object[required_key.to_sym]
+          end
+
+          required_key_values
+        end
+
+      end
+    end
+  end
+end

data/lib/genesis_ruby/utils/formatters/response/definitions.rb

@@ -0,0 +1,21 @@
+require 'genesis_ruby/utils/formatters/response/formats/amount'
+require 'genesis_ruby/utils/formatters/response/formats/timestamp'
+
+module GenesisRuby
+  module Utils
+    module Formatters
+      # Definition of all available Response Formatters
+      module Response
+
+        # Array of string of all available Response Formatters
+        def available_formatters
+          [
+            GenesisRuby::Utils::Formatters::Response::Formats::Amount,
+            GenesisRuby::Utils::Formatters::Response::Formats::Timestamp
+          ]
+        end
+
+      end
+    end
+  end
+end

data/lib/genesis_ruby/utils/formatters/response/formats/amount.rb

@@ -0,0 +1,34 @@
+require 'genesis_ruby/utils/formatters/base'
+require 'genesis_ruby/utils/money_format'
+
+module GenesisRuby
+  module Utils
+    module Formatters
+      module Response
+        module Formats
+          # Response Amount Formatter. Converts Minor Currency to Major currency format
+          class Amount < Base
+
+            # The Response keys that the formatter will be applied to
+            def formatting_keys
+              %w(amount leftover_amount)
+            end
+
+            # The keys required for formatting the specific response key
+            def required_keys
+              %w(currency)
+            end
+
+            # Format the given amount response key and its currency to major currency format
+            def format_key(amount, currency)
+              GenesisRuby::Utils::MoneyFormat.exponent_to_amount(amount, currency)
+            rescue StandardError
+              amount
+            end
+
+          end
+        end
+      end
+    end
+  end
+end