burlap 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a943c13d8d1a707bb5cd7aa90b1044294f3ac83e92bbc9dc47013bc665646015
+  data.tar.gz: 148192348442c2b25471c582c35800f38f37bed6275e54db5d29f40dfade6659
+SHA512:
+  metadata.gz: 887990e582c68cc1603786307e76cc02f75e9770d01404e21e84f42ed4584c578614e704874f33504a0b33ae5c97287aa57b109e4b2e913d311e299a8888cd13
+  data.tar.gz: d00650665f60de24108f908bb804a15d835bb61957a473ae15f6e63d6c842c23e675be8a3362dac1c9583e61f8865b851db27c8b61eeb04bb298cfce91ee2c50

data/.github/workflows/ruby.yml

@@ -0,0 +1,38 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: Ruby
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ["2.3", "2.4", "2.5", "2.6", "2.7", "3.0", "3.1"]
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@55283cc23133118229fd3f97f9336ee23a179fcf # v1.146.0
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run tests
+      run: bundle exec rspec

data/.gitignore

@@ -0,0 +1,9 @@
+pkg/*
+*.gem
+.bundle
+tmp/*
+log/*
+doc/*
+.yardoc
+Gemfile.lock
+vendor

data/.rspec

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

data/.yardopts

@@ -0,0 +1 @@
+--markup=markdown

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2010 Brightbox Systems Ltd
+
+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,16 @@
+# Burlap
+
+This gem handles parsing and generating [Burlap][] XML.
+
+
+## Installation
+
+	gem install burlap
+
+or from the git repo
+
+	rake install
+
+## Development
+
+Clone the git repo

data/Rakefile

@@ -0,0 +1,31 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+begin
+  require "rspec/core/rake_task"
+  require "rspec/core/version"
+
+  desc "Run all examples"
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = %w(--color)
+  end
+rescue LoadError
+  # rspec not loaded, tasks not available
+  desc "[RSpec failed to load] Run all examples"
+  task :spec do
+    fail "RSpec failed to load, this task can't be run"
+  end
+end
+
+desc "Alias for spec"
+task :test => :spec
+
+begin
+  require "yard"
+
+  YARD::Rake::YardocTask.new :doc do |yard|
+    yard.files = Dir.glob("lib/**/*.rb")
+  end
+rescue LoadError
+  puts "failed to load yard"
+end

data/burlap.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "burlap/version"
+
+Gem::Specification.new do |s|
+  s.name        = "burlap"
+  s.version     = Burlap::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Caius Durling", "Paul Thornthwaite", "John Leach"]
+  s.email       = ["hello@brightbox.com"]
+  s.homepage    = "https://github.com/brightbox/burlap"
+  s.summary     = %q{Wrapper for burlap APIs}
+  s.description = %q{Translates responses from Burlap APIs to ruby, and generates requests to send back.}
+  s.license     = "MIT"
+  s.metadata['rubygems_mfa_required'] = "true"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = "> 2.3"
+
+  s.add_dependency "nokogiri", ">= 1.4.4"
+  s.add_dependency "builder", ">= 2.0"
+
+  s.add_development_dependency "rspec", "~> 3.0"
+  s.add_development_dependency "activesupport", ">= 2.3.4"
+  s.add_development_dependency "timecop", "= 0.3.5"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "yard"
+end

data/lib/active_support/ordered_hash.rb

@@ -0,0 +1,179 @@
+require 'yaml'
+
+YAML.add_builtin_type("omap") do |type, val|
+  ActiveSupport::OrderedHash[val.map(&:to_a).map(&:first)]
+end
+
+# OrderedHash is namespaced to prevent conflicts with other implementations
+module ActiveSupport #:nodoc:
+  class OrderedHash < ::Hash #:nodoc:
+    def to_yaml_type
+      "!tag:yaml.org,2002:omap"
+    end
+
+    def to_yaml(opts = {})
+      YAML.quick_emit(self, opts) do |out|
+        out.seq(taguri, to_yaml_style) do |seq|
+          each do |k, v|
+            seq.add(k => v)
+          end
+        end
+      end
+    end
+
+    # Hash is ordered in Ruby 1.9!
+    if RUBY_VERSION < '1.9'
+
+      # In MRI the Hash class is core and written in C. In particular, methods are
+      # programmed with explicit C function calls and polymorphism is not honored.
+      #
+      # For example, []= is crucial in this implementation to maintain the @keys
+      # array but hash.c invokes rb_hash_aset() originally. This prevents method
+      # reuse through inheritance and forces us to reimplement stuff.
+      #
+      # For instance, we cannot use the inherited #merge! because albeit the algorithm
+      # itself would work, our []= is not being called at all by the C code.
+
+      def initialize(*args, &block)
+        super
+        @keys = []
+      end
+
+      def self.[](*args)
+        ordered_hash = new
+
+        if (args.length == 1 && args.first.is_a?(Array))
+          args.first.each do |key_value_pair|
+            next unless (key_value_pair.is_a?(Array))
+            ordered_hash[key_value_pair[0]] = key_value_pair[1]
+          end
+
+          return ordered_hash
+        end
+
+        unless (args.size % 2 == 0)
+          raise ArgumentError.new("odd number of arguments for Hash")
+        end
+
+        args.each_with_index do |val, ind|
+          next if (ind % 2 != 0)
+          ordered_hash[val] = args[ind + 1]
+        end
+
+        ordered_hash
+      end
+
+      def initialize_copy(other)
+        super
+        # make a deep copy of keys
+        @keys = other.keys
+      end
+
+      def []=(key, value)
+        @keys << key if !has_key?(key)
+        super
+      end
+
+      def delete(key)
+        if has_key? key
+          index = @keys.index(key)
+          @keys.delete_at index
+        end
+        super
+      end
+
+      def delete_if
+        super
+        sync_keys!
+        self
+      end
+
+      def reject!
+        super
+        sync_keys!
+        self
+      end
+
+      def reject(&block)
+        dup.reject!(&block)
+      end
+
+      def keys
+        @keys.dup
+      end
+
+      def values
+        @keys.collect { |key| self[key] }
+      end
+
+      def to_hash
+        self
+      end
+
+      def to_a
+        @keys.map { |key| [ key, self[key] ] }
+      end
+
+      def each_key
+        @keys.each { |key| yield key }
+      end
+
+      def each_value
+        @keys.each { |key| yield self[key]}
+      end
+
+      def each
+        @keys.each {|key| yield [key, self[key]]}
+      end
+
+      alias_method :each_pair, :each
+
+      def clear
+        super
+        @keys.clear
+        self
+      end
+
+      def shift
+        k = @keys.first
+        v = delete(k)
+        [k, v]
+      end
+
+      def merge!(other_hash)
+        if block_given?
+          other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
+        else
+          other_hash.each { |k, v| self[k] = v }
+        end
+        self
+      end
+
+      alias_method :update, :merge!
+
+      def merge(other_hash, &block)
+        dup.merge!(other_hash, &block)
+      end
+
+      # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+      def replace(other)
+        super
+        @keys = other.keys
+        self
+      end
+
+      def invert
+        OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
+      end
+
+      def inspect
+        "#<OrderedHash #{super}>"
+      end
+
+      private
+        def sync_keys!
+          @keys.delete_if {|k| !has_key?(k)}
+        end
+    end
+  end
+end

data/lib/burlap/array.rb

@@ -0,0 +1,18 @@
+module Burlap
+  class Array < ::Array
+
+    def to_burlap
+      # <list><type>[string</type><length>1</length><string>Some</string></list>
+      list_content = [
+        Burlap::Node.new(:name => "type", :value => "").to_burlap,
+        Burlap::Node.new(:name => "length", :value => self.length.to_s).to_burlap
+      ]
+      list_content += self.map do |element|
+        element.to_burlap
+      end
+      list_content = list_content.join("")
+      Burlap::Node.new(:name => "list", :value => list_content).to_burlap
+    end
+
+  end
+end

data/lib/burlap/base_tag.rb

@@ -0,0 +1,105 @@
+module Burlap
+
+  class BaseTag
+    attr_accessor :name, :value, :children
+
+    def initialize params={}
+      params.each do |k,v|
+        meffod = :"#{k}="
+        send(meffod, v) if respond_to?(meffod)
+      end
+    end
+
+    def children
+      @children ||= []
+    end
+
+    def value
+      @value ||= ""
+    end
+
+    def parse_matched_pairs
+      # The children are matched pairs.
+      # We use an array here because ruby 1.8.x is _FUN_ to
+      # use ordered hashes with and doing it in an array is
+      # easier for now. Viva la 1.9!
+      values = []
+
+      self.children.each_slice(2) do |arr|
+        key = arr.first.to_ruby
+        value = if arr.last.name == "ref"
+          i = arr.last.value.to_i - 1
+          v = values[i]
+          v.last if v
+        else
+          arr.last.to_ruby
+        end
+
+        values << [key, value]
+      end
+
+      values
+    end
+
+    def to_ruby
+      Burlap.resolver.convert_to_native self
+    end
+
+  end
+
+end
+
+__END__
+
+# todo: introduce into resolver block for map
+class Timestamp < Map
+  handle_mapping "java.sql.Timestamp"
+
+  def to_ruby
+    # This is already parsed as a Time object
+    contents["value"]
+  end
+end
+
+# todo: introduce into resolver block for map
+require "bigdecimal"
+class BigDecimal < Map
+  handle_mapping "java.math.BigDecimal"
+
+  def to_ruby
+    ::BigDecimal.new(contents["value"])
+  end
+end
+end
+
+# todo: add a resolver block to parse this out
+class Fault
+  attr_reader :code, :message, :detail_message, :stack_trace, :cause
+
+  def initialize opts={}
+    data = opts[:contents]
+
+    @message = data["message"]
+    @code = data["code"]
+    detail = data["detail"].contents
+    @detail_message = detail["detailMessage"]
+    @stack_trace = detail["stackTrace"]
+    @cause = detail["cause"]
+
+    @contents = nil
+  end
+end
+
+# todo: add a resolver block for this logic
+class FaultTag < BaseTag
+  def to_ruby
+    dict = {}
+
+    children.each_slice(2) do |arr|
+      key, value = arr.map(&:to_ruby)
+      dict[key] = value
+    end
+
+    Fault.new(:contents => dict)
+  end
+end

data/lib/burlap/call.rb

@@ -0,0 +1,38 @@
+module Burlap
+  class Call
+    attr_accessor :headers, :method, :arguments
+
+    def initialize params={}
+      params.each do |key, value|
+        method = :"#{key}="
+        send(method, value) if respond_to?(method)
+      end
+
+      validate_attributes
+    end
+
+    def headers
+      @headers ||= {}
+    end
+
+    def arguments
+      @arguments ||= []
+    end
+
+    def to_burlap
+      # todo: handle headers
+      contents = [Burlap::Node.new(:name => "method", :value => method).to_burlap]
+      contents += arguments.map do |arg|
+        arg.to_burlap
+      end
+      Burlap::Node.new(:name => "burlap:call", :value => contents.join("")).to_burlap
+    end
+
+  protected
+
+    def validate_attributes
+      raise(ArgumentError, "method is required") unless self.method
+    end
+
+  end
+end

data/lib/burlap/core_ext/array.rb

@@ -0,0 +1,7 @@
+class Array
+  def to_burlap
+    # We use the splat here so it creates an array with our elements,
+    # rather than an array containing an array of our elements
+    Burlap::Array[*to_a].to_burlap
+  end
+end

data/lib/burlap/core_ext/boolean.rb

@@ -0,0 +1,11 @@
+class TrueClass
+  def to_burlap
+    Burlap::Node.new(:name => "boolean", :value => "1").to_burlap
+  end
+end
+
+class FalseClass
+  def to_burlap
+    Burlap::Node.new(:name => "boolean", :value => "0").to_burlap
+  end
+end

data/lib/burlap/core_ext/float.rb

@@ -0,0 +1,5 @@
+class Float
+  def to_burlap
+    Burlap::Node.new(:name => "double", :value => self).to_burlap
+  end
+end

data/lib/burlap/core_ext/hash.rb

@@ -0,0 +1,5 @@
+class Hash
+  def to_burlap
+    Burlap::Hash[self].to_burlap
+  end
+end

data/lib/burlap/core_ext/integer.rb

@@ -0,0 +1,10 @@
+class Integer
+  def to_burlap
+    if between?(-2**31, 2**31-1)
+      Burlap::Node.new(:name => "int", :value => self.to_i).to_burlap
+    else
+      # <map><type>java.math.BigDecimal</type><string>value</string><string>0</string></map>
+      Burlap::Hash[{:value => self.to_i.to_s}, "java.math.BigDecimal"].to_burlap
+    end
+  end
+end

data/lib/burlap/core_ext/nil.rb

@@ -0,0 +1,5 @@
+class NilClass
+  def to_burlap
+    Burlap::Node.new(:name => "null", :value => "").to_burlap
+  end
+end

data/lib/burlap/core_ext/object.rb

@@ -0,0 +1,13 @@
+class Object
+  def to_burlap
+    dict = {}
+
+    vars = instance_variables.map do |var|
+      key = var[/^@(.*)$/, 1]
+      value = instance_variable_get(var)
+      [key, value]
+    end.sort_by {|e| e.first }
+
+    Burlap::Hash[vars, self.class.to_s].to_burlap
+  end
+end

data/lib/burlap/core_ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def to_burlap
+    Burlap::Node.new(:name => "string", :value => ERB::Util.html_escape(self)).to_burlap
+  end
+end

data/lib/burlap/core_ext/symbol.rb

@@ -0,0 +1,6 @@
+class Symbol
+  def to_burlap
+    # Return the same as if we were a string
+    self.to_s.to_burlap
+  end
+end

data/lib/burlap/core_ext/time.rb

@@ -0,0 +1,5 @@
+class Time
+  def to_burlap
+    Burlap::Node.new(:name => "date", :value => self.burlap_iso8601(3)).to_burlap
+  end
+end

data/lib/burlap/core_ext.rb

@@ -0,0 +1,10 @@
+require "burlap/core_ext/array"
+require "burlap/core_ext/boolean"
+require "burlap/core_ext/float"
+require "burlap/core_ext/hash"
+require "burlap/core_ext/integer"
+require "burlap/core_ext/nil"
+require "burlap/core_ext/object"
+require "burlap/core_ext/string"
+require "burlap/core_ext/symbol"
+require "burlap/core_ext/time"