burlap 1.0.0

data/lib/burlap/default_resolver.rb

@@ -0,0 +1,100 @@
+require "time"
+require "ostruct"
+
+module Burlap
+  class DefaultResolver
+    def mappings(*names, &block)
+      # Default's to a hash
+      @mappings ||= {}
+      # return early, return often. Or is that release?
+      return @mappings if names.empty?
+
+      # Set said block for each name
+      names.each do |name|
+        @mappings[name] = proc(&block)
+      end
+
+      @mappings
+    end
+
+    # obj is expected to respond to #name, #value and #children
+    # (eg, an instance of BaseTag)
+    def convert_to_native obj
+      mapping = mappings[obj.name] || raise(Error, "couldn't handle tag #{obj.name.inspect}")
+      mapping.call(obj)
+    end
+  end
+
+  # And set ourselves as the default
+  self.resolver ||= DefaultResolver.new
+end
+
+Burlap.resolver.mappings "burlap:reply" do |tag|
+  tag.children.first.to_ruby if tag.children.first
+end
+
+Burlap.resolver.mappings "map" do |tag|
+  # Pop the first element off
+  t = tag.children.shift.to_ruby
+
+  # then parse the rest of the children as key/values
+  values = tag.parse_matched_pairs
+
+  Burlap::Hash[values, t]
+end
+
+Burlap.resolver.mappings "fault" do |tag|
+  # Parse the children as key/values
+  values = tag.parse_matched_pairs
+
+  # and then turn it into an open struct
+  if RUBY_VERSION > '1.9'
+    Burlap::Fault.new(Hash[values])
+  else
+    Burlap::Fault.new(values)
+  end
+end
+
+Burlap.resolver.mappings "type", "string" do |tag|
+  tag.value.to_s
+end
+
+Burlap.resolver.mappings "int", "length" do |tag|
+  tag.value.to_i
+end
+
+Burlap.resolver.mappings "double" do |tag|
+  tag.value.to_f
+end
+
+Burlap.resolver.mappings "null" do |tag|
+  nil
+end
+
+Burlap.resolver.mappings "date" do |tag|
+  ::Time.parse(tag.value) if tag.value
+end
+
+Burlap.resolver.mappings "list" do |tag|
+  # We don't actually care about the type or length of the
+  # array in ruby, but we shift it out the way so we can ignore it.
+  t = tag.children.shift.to_ruby
+  length = tag.children.shift.to_ruby
+
+  # Parse the rest of the children as key/values
+  values = tag.children.map &:to_ruby
+
+  Burlap::Array[*values]
+end
+
+Burlap.resolver.mappings "ref" do |tag|
+  tag.value
+end
+
+Burlap.resolver.mappings "boolean" do |tag|
+  tag.value.to_i == 1
+end
+
+Burlap.resolver.mappings "base64" do |tag|
+  Base64.decode64(tag.value.to_s)
+end

data/lib/burlap/error.rb

@@ -0,0 +1,3 @@
+module Burlap
+  Error = Class.new(StandardError)
+end

data/lib/burlap/fault.rb

@@ -0,0 +1,6 @@
+require "ostruct"
+
+module Burlap
+  class Fault < OpenStruct
+  end
+end

data/lib/burlap/hash.rb

@@ -0,0 +1,72 @@
+require "active_support/ordered_hash"
+
+module Burlap
+  # todo: subclass ::Hash once this is 1.9.2 only
+  class Hash < ActiveSupport::OrderedHash
+    attr_writer :__type__
+
+    # We override this to allow a type to be set upon object initialization.
+    # As we subclass Hash and call super it should behave exactly the same
+    # as Hash#[].
+    #
+    # NB: we actually subclass ActiveSupport::OrderedHash for ordered hash support
+    # in ruby 1.8.x, which means we don't behave exactly like Hash#[] on 1.8.x. Sucks.
+    #
+    # Examples:
+    #
+    #   Burlap::Hash[:one => :two] # => {:one => :two}, type == ""
+    #   Burlap::Hash[{:one => :two}, "fred"] # => {:one => :two}, type == "fred"
+    #
+    def self.[] *args
+      if args.size == 2 && args[1].is_a?(::String)
+        h = super(args[0].to_a)
+        h.__type__ = args[1]
+        h
+      elsif args.size == 1 && args[0].is_a?(::Hash)
+        super(args[0].to_a)
+      else
+        super
+      end
+    end
+
+    # Accessor for the type attribute, defaults to an empty string
+    def __type__
+      @__type__ ||= ""
+    end
+
+    # Build a string for ourselves, including both __type__ and the hash
+    def inspect
+      # we have to build our hash string manually so it's ordered, can't call #to_h.inspect under 1.8
+      # as that returns an _un_ordered hash.
+      "#<#{self.class} __type__=#{__type__.inspect} {#{map {|k,v| "#{k.inspect}=>#{v.inspect}"}.join(", ")}}>"
+    end
+
+    # Return ourselves as a plain old ruby Hash
+    def to_h
+      ::Hash[self]
+    end
+
+    # Converts the hash into a string of XML, calling #to_burlap on all keys &
+    # values. Builds a <map> element, with type set then all key/values following.
+    def to_burlap
+      # Build the node for the type
+      contents = [Burlap::Node.new(
+        :name => "type",
+        :value => self.__type__
+      )]
+
+      # Build nodes for all the content
+      contents += self.map do |k,v|
+        [k, v]
+      end.flatten(1)
+
+      content = contents.map(&:to_burlap).join("")
+
+      Burlap::Node.new(
+        :name => "map",
+        :value => content
+      ).to_burlap
+    end
+
+  end
+end

data/lib/burlap/listener.rb

@@ -0,0 +1,34 @@
+require "nokogiri"
+
+module Burlap
+  class Listener < Nokogiri::XML::SAX::Document
+    attr_accessor :result
+
+    def initialize
+      @result = nil
+      @open = []
+    end
+
+    def start_element name, attrs=[]
+      @open.push BaseTag.new(:name => name)
+    end
+
+    def characters contents
+      @open.last.value += contents if @open.last
+    end
+
+    def end_element name
+      last = @open.pop
+      if @open.empty?
+        @result = last.to_ruby
+      else
+        @open.last.children.push last
+      end
+    end
+
+  private
+    attr_writer :data
+
+  end
+
+end

data/lib/burlap/node.rb

@@ -0,0 +1,48 @@
+module Burlap
+  class Node
+    attr_accessor :name, :value
+
+    # name is the element name to go in the <>
+    # and value is a string to go in the node
+    def initialize params={}
+      params.each do |k,v|
+        meffod = :"#{k}="
+        send(meffod, v) #if respond_to?(meffod)
+      end
+    end
+
+    # Packs this object into nokogiri nodes and returns the XML as a string
+    def to_burlap
+      doc = Nokogiri::XML::Document.new
+      root = Nokogiri::XML::Node.new(self.name, doc)
+
+      if self.value.to_s == ""
+        root.children = self.value.to_s
+      else
+        root << self.value.to_s
+      end
+
+      convert_hex_entities_to_decimal root.to_xml(nokogiri_xml_options)
+    end
+
+  protected
+    def nokogiri_xml_options
+      {:indent => 0, :indent_text => "", :save_with => Nokogiri::XML::Node::SaveOptions::AS_HTML}
+    end
+
+    # Converts all hex entities into decimal entities.
+    # 
+    # eg: &#xE5; into &#229;
+    # 
+    # @param [String, #gsub] string string to convert entities in
+    # @return [String] string with decimal entities
+    def convert_hex_entities_to_decimal string
+      string.gsub(/&#x[0-9a-f]+;/i) do |match|
+        # Extract the hex value and convert to decimal
+        dec = match[/x([0-9a-f]+;)/i, 1].to_i(16)
+
+        "&##{dec};"
+      end
+    end
+  end
+end

data/lib/burlap/version.rb

@@ -0,0 +1,3 @@
+module Burlap
+  VERSION = "1.0.0"
+end

data/lib/burlap.rb

@@ -0,0 +1,47 @@
+module Burlap
+  # Stores the resolver object for parsing burlap
+  class << self
+    attr_accessor :resolver
+  end
+
+  # Turns a burlap string read from `io_handle` into native
+  # ruby objects.
+  def self.parse(io_handle, strict = false)
+    listener = Listener.new
+    parser = Nokogiri::XML::SAX::Parser.new(listener)
+
+    if strict && io_handle.encoding != Encoding::UTF_8
+      io_handle.encode!(Encoding::UTF_8)
+    end
+
+    parser.parse(io_handle)
+    listener.result
+  end
+
+  # Turns `obj` into a burlap XML representation
+  def self.dump obj
+    if obj.respond_to?(:to_burlap)
+      obj.to_burlap
+    else
+      raise Error, "couldn't dump #{obj.inspect}"
+    end
+  end
+end
+
+require "base64"
+require "erb"
+require "core_ext/time_burlap_iso8601"
+
+require "burlap/default_resolver"
+# burlap/version already got included by gemspec
+require "burlap/error"
+require "burlap/array"
+require "burlap/hash"
+
+require "burlap/node"
+require "burlap/core_ext" # todo: make optional?
+require "burlap/base_tag"
+require "burlap/fault"
+
+require "burlap/call"
+require "burlap/listener"

data/lib/core_ext/time_burlap_iso8601.rb

@@ -0,0 +1,32 @@
+require "time"
+
+module TimeBurlapIso8601
+  # Burlap needs #iso8601 without any dashes or colons. It mimics the 1.8 implementation
+  # of #iso8601, including not having a dependency on #strftime.
+  # 
+  # @param [Integer] fraction_digits number of digits of milliseconds wanted
+  # @return [String] 
+  # 
+  def burlap_iso8601 fraction_digits=0
+    sprintf("%d%02d%02dT%02d%02d%02d", year, mon, day, hour, min, sec) + \
+
+    case fraction_digits
+    when 0
+      ""
+    when 1..6
+      sprintf(".%06d", usec)[0..3]
+    else
+      sprintf(".%06d", usec) + "0" * (fraction_digits - 6)
+    end + \
+
+    if utc?
+      'Z'
+    else
+      off = utc_offset
+      sign = off < 0 ? '-' : '+'
+      sprintf('%s%02d:%02d', sign, *(off.abs / 60).divmod(60))
+    end
+  end
+end
+
+Time.send(:include, TimeBurlapIso8601)

data/spec/burlap/array_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+RSpec.describe Burlap::Array do
+  describe "#to_burlap" do
+    subject(:burlap) { array.to_burlap }
+
+    let(:array) { described_class["some", mock_obj] }
+    let(:mock_obj) { instance_double(Object, to_burlap: "<mock>my stuff here</mock>") }
+
+    it "returns a string" do
+      expect(burlap).to be_a_kind_of(String)
+    end
+
+    it "is correct" do
+      xml_string = <<-XML
+      <list>
+        <type></type>
+        <length>2</length>
+        <string>some</string>
+        <mock>my stuff here</mock>
+      </list>
+      XML
+
+      format_xml_as_burlap(xml_string)
+      expect(burlap).to eq(xml_string)
+    end
+  end
+end

data/spec/burlap/call_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+
+RSpec.describe Burlap::Call do
+  subject(:caller) { described_class.new(caller_args) }
+
+  let(:caller_args) { { method: "updateUser" } }
+
+  describe "#headers" do
+    it "defaults to an array" do
+      expect(caller.headers).to eq({})
+    end
+  end
+
+  describe "#arguments" do
+    it "defaults to a hash" do
+      expect(caller.arguments).to eq([])
+    end
+  end
+
+  describe "#method" do
+    subject(:caller) { described_class.new({}) }
+
+    it "is required" do
+      expect { caller }.to raise_error(ArgumentError, "method is required")
+    end
+  end
+
+  describe "#to_burlap" do
+    subject(:burlap) { caller.to_burlap }
+
+    before { Timecop.freeze(Time.local(2010, 9, 11, 10, 0, 0)) }
+
+    after  { Timecop.return }
+
+    context "single dimensional" do
+      let(:caller_args) { { method: "updateUser", arguments: ["one", 2, 3.0, nil, true, Time.now] } }
+
+      it "has a burlap:call root" do
+        expect(burlap).to match(/\A<burlap:call>/)
+        expect(burlap).to match(%r{</burlap:call>\z})
+      end
+
+      it "has a method element" do
+        expect(burlap).to match(%r{<method>updateUser</method>})
+      end
+
+      it "has a string argument element" do
+        expect(burlap).to match(%r{<string>one</string>})
+      end
+
+      it "has an int argument element" do
+        expect(burlap).to match(%r{<int>2</int>})
+      end
+
+      it "has a double argument element" do
+        expect(burlap).to match(%r{<double>3.0</double>})
+      end
+
+      it "has a null argument element" do
+        expect(burlap).to match(%r{<null></null>})
+      end
+
+      it "has a boolean argument element" do
+        expect(burlap).to match(%r{<boolean>1</boolean>})
+      end
+
+      it "has a date argument element" do
+        expect(burlap).to match(%r{<date>#{Regexp.escape(Time.now.burlap_iso8601(3))}</date>})
+      end
+    end
+
+    context "multi-dimensional" do
+      let(:caller_args) { { method: "updateUser", arguments: ["one", contact] } }
+      let(:contact) do
+        Burlap::Hash[
+          [
+            ["number", 101],
+            ["street", "auckland road"],
+            %w[town elizabethtown],
+            %w[country finland],
+            ["foreign", true]
+          ],
+          "burlap.user"
+        ]
+      end
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "generates the right burlap" do
+        # TODO: add headers
+        xml_string = <<-XML
+          <burlap:call>
+            <method>updateUser</method>
+
+            <string>one</string>
+
+            <map>
+              <type>burlap.user</type>
+
+              <string>number</string>
+              <int>101</int>
+
+              <string>street</string>
+              <string>auckland road</string>
+
+              <string>town</string>
+              <string>elizabethtown</string>
+
+              <string>country</string>
+              <string>finland</string>
+
+              <string>foreign</string>
+              <boolean>1</boolean>
+            </map>
+
+          </burlap:call>
+        XML
+
+        format_xml_as_burlap(xml_string)
+        expect(burlap).to eq(xml_string)
+      end
+    end
+  end
+end

data/spec/burlap/core_ext/array_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+RSpec.describe Array do
+  describe "#to_burlap" do
+    subject(:burlap) { array.to_burlap }
+
+    context "with 0 elements" do
+      let(:array) { [] }
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "has a list root" do
+        expect(burlap).to match(/^<list>/)
+        expect(burlap).to match(%r{</list>$})
+      end
+
+      it "has a type element" do
+        expect(burlap).to match(%r{<type></type>})
+      end
+
+      it "has a length element" do
+        expect(burlap).to match(%r{<length>#{array.size}</length>})
+      end
+
+      it "creates a Burlap::Array instance from itself and delegate #to_burlap to it" do
+        mock_burlap_array = instance_double(Burlap::Array)
+        expect(Burlap::Array).to receive(:[]).with(no_args).and_return(mock_burlap_array)
+        expect(mock_burlap_array).to receive(:to_burlap).and_return("<burlap>array</burlap>")
+
+        expect(array.to_burlap).to eq("<burlap>array</burlap>")
+      end
+    end
+
+    context "with 1 element" do
+      let(:array) { [:one] }
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "has a list root" do
+        expect(burlap).to match(/^<list>/)
+        expect(burlap).to match(%r{</list>$})
+      end
+
+      it "has a type element" do
+        expect(burlap).to match(%r{<type></type>})
+      end
+
+      it "has a length element" do
+        expect(burlap).to match(%r{<length>#{array.size}</length>})
+      end
+
+      it "creates a Burlap::Array instance from itself and delegate #to_burlap to it" do
+        mock_burlap_array = instance_double(Burlap::Array)
+        expect(Burlap::Array).to receive(:[]).with(*array).and_return(mock_burlap_array)
+        expect(mock_burlap_array).to receive(:to_burlap).and_return("<burlap>array</burlap>")
+
+        expect(array.to_burlap).to eq("<burlap>array</burlap>")
+      end
+    end
+
+    context "with 2 elements" do
+      let(:array) { [:one, "two"] }
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "has a list root" do
+        expect(burlap).to match(/^<list>/)
+        expect(burlap).to match(%r{</list>$})
+      end
+
+      it "has a type element" do
+        expect(burlap).to match(%r{<type></type>})
+      end
+
+      it "has a length element" do
+        expect(burlap).to match(%r{<length>#{array.size}</length>})
+      end
+
+      it "creates a Burlap::Array instance from itself and delegate #to_burlap to it" do
+        mock_burlap_array = instance_double(Burlap::Array)
+        expect(Burlap::Array).to receive(:[]).with(*array).and_return(mock_burlap_array)
+        expect(mock_burlap_array).to receive(:to_burlap).and_return("<burlap>array</burlap>")
+
+        expect(array.to_burlap).to eq("<burlap>array</burlap>")
+      end
+    end
+
+    context "with 3 elements" do
+      let(:array) { [:one, "two", 3] }
+
+      it "returns a string" do
+        expect(burlap).to be_a_kind_of(String)
+      end
+
+      it "has a list root" do
+        expect(burlap).to match(/^<list>/)
+        expect(burlap).to match(%r{</list>$})
+      end
+
+      it "has a type element" do
+        expect(burlap).to match(%r{<type></type>})
+      end
+
+      it "has a length element" do
+        expect(burlap).to match(%r{<length>#{array.size}</length>})
+      end
+
+      it "creates a Burlap::Array instance from itself and delegate #to_burlap to it" do
+        mock_burlap_array = instance_double(Burlap::Array)
+        expect(Burlap::Array).to receive(:[]).with(*array).and_return(mock_burlap_array)
+        expect(mock_burlap_array).to receive(:to_burlap).and_return("<burlap>array</burlap>")
+
+        expect(array.to_burlap).to eq("<burlap>array</burlap>")
+      end
+    end
+  end
+end

data/spec/burlap/core_ext/class_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Class do
+  describe "#to_burlap" do
+    subject(:burlap) { described_class.new.to_burlap }
+
+    # FIXME: The comment "we can't dump anonymous classes" implies this
+    #        shouldn't work or it shouldn't work as it currently does
+    #        but the intent has been lost. This test confirms the
+    #        current behaviour as implemented.
+    #
+    it "doesn't raise an error" do
+      expect { burlap }.not_to raise_error
+    end
+
+    it "returns a string" do
+      expect(burlap).to be_a_kind_of(String)
+    end
+
+    it "is returning a string..." do
+      expect(burlap).to eq("<map><type>Class</type></map>")
+    end
+  end
+end

data/spec/burlap/core_ext/false_class_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+RSpec.describe FalseClass do
+  describe "#to_burlap" do
+    before do
+      @result = false.to_burlap
+    end
+
+    it "returns a string" do
+      expect(@result).to be_a_kind_of(String)
+    end
+
+    it "is correct" do
+      expect(@result).to eq("<boolean>0</boolean>")
+    end
+  end
+end

data/spec/burlap/core_ext/float_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+RSpec.describe Float do
+  describe "#to_burlap" do
+    subject(:burlap) { 5.0.to_burlap }
+
+    it "returns a string" do
+      expect(burlap).to be_a_kind_of(String)
+    end
+
+    it "is correct" do
+      expect(burlap).to eq("<double>5.0</double>")
+    end
+  end
+end