RubyGems - jaxb2ruby - Versions diffs - 0.0.1-java - Mend

jaxb2ruby 0.0.1-java

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

checksums.yaml +7 -0
data/bin/jaxb2ruby +90 -0
data/lib/jaxb2ruby.rb +15 -0
data/lib/jaxb2ruby/classes.rb +184 -0
data/lib/jaxb2ruby/config.xjb +16 -0
data/lib/jaxb2ruby/converter.rb +250 -0
data/lib/jaxb2ruby/template.rb +33 -0
data/lib/jaxb2ruby/type_util.rb +90 -0
data/lib/jaxb2ruby/version.rb +3 -0
data/lib/jaxb2ruby/xjc.rb +59 -0
data/lib/templates/happymapper.erb +39 -0
data/lib/templates/roxml.erb +42 -0
data/lib/templates/ruby.erb +44 -0
data/lib/templates/util/happymapper.rb +26 -0
data/lib/templates/util/roxml.rb +29 -0
data/spec/converter_spec.rb +213 -0
data/spec/spec_helper.rb +25 -0
data/spec/template_spec.rb +128 -0
metadata +113 -0

data/lib/jaxb2ruby/template.rb ADDED

@@ -0,0 +1,33 @@
+require "erb"
+module JAXB2Ruby
+  class Template  # :nodoc:
+    HEADING=<<HEAD
+#
+# Auto-generated by jaxb2ruby v<%= VERSION %> on <%= Time.now %>
+# https://github.com/sshaw/jaxb2ruby
+#
+HEAD
+    PATHS = Hash[
+      Dir[File.expand_path(__FILE__ + "/../../templates/*.erb")].map do |path|
+        [File.basename(path, ".erb"), path]
+      end
+    ]
+    DEFAULT = PATHS["roxml"]
+    def initialize(name = nil)
+      # If it's not a named template assume it's a path
+      path = PATHS[name] || name || DEFAULT
+      @__erb = ERB.new(HEADING + File.read(path), nil, "<>%-")
+    rescue => e
+      raise Error, "cannot load class template: #{e}"
+    end
+    def build(klass)
+      @class = klass
+      @__erb.result(binding)
+    end
+  end
+end

data/lib/jaxb2ruby/type_util.rb ADDED

@@ -0,0 +1,90 @@
+module JAXB2Ruby
+  class TypeUtil  # :nodoc:
+    # Only includes types that aren't annotated with @XmlSchemaType
+    JAVA_TO_SCHEMA = {
+      "java.lang.Boolean" => "boolean",
+      "boolean" => "boolean",
+      "byte" => "byte",
+      # byte[]
+      "[B" => "base64Binary",
+      "double" => "double",
+      "float" => "float",
+      "java.lang.Integer" => "int",
+      "int" => "int",
+      "java.lang.Object" => "anySimpleType",
+      "java.lang.String" => "string",
+      "java.math.BigDecimal" => "decimal",
+      "java.math.BigInteger" => "int",
+      "javax.xml.datatype.Duration" => "duration",
+      "javax.xml.datatype.XMLGregorianCalendar" => "dateTime",
+      #"javax.xml.namespace.QName" => "NOTATION"
+      "javax.xml.namespace.QName" => "QName",
+      "java.lang.Long" => "long",
+      "long" => "long",
+      "short" => "short"
+    }
+    SCHEMA_TO_RUBY = {
+      "ID" => :ID,
+      "IDREF" => :IDREF,
+      "Name" => "String",
+      "NCName" => "String",
+      "NMTOKEN" => "String",
+      "anySimpleType" => "Object",
+      "anyType" => "Object",
+      "anyURI" => "String",
+      "base64Binary" => "String",
+      "boolean" => :boolean,
+      "byte" => "Integer",
+      "date" => "Date",
+      "dateTime" => "DateTime",
+      "decimal" => "Float",  # BigDecimal
+      "double" => "Float",
+      "duration" => "String",
+      "float"  => "Float",
+      "gDay" => "String",
+      "gMonth" => "String",
+      "gMonthDay" => "String",
+      "gYear" => "String",
+      "gYearMonth" => "String",
+      "hexBinary" => "String",
+      "int" => "Integer",
+      "integer" => "Integer",
+      "long" => "Integer",
+      "language" => "String",
+      "nonNegativeInteger" => "Integer",
+      "nonPositiveInteger" => "Integer",
+      "normalizedString" => "String",
+      "positiveInteger" => "Integer",
+      "QName" => "String",
+      "short" => "Integer",
+      "string" => "String",
+      "time" => "Time",
+      "token" => "String",
+      "unsignedByte" => "Integer",
+      "unsignedInt" => "Integer",
+      "unsignedLong" => "Integer",
+      "unsignedShort" => "Integer"
+    }
+    def initialize(schema2ruby)
+      @schema2ruby = SCHEMA_TO_RUBY.merge(schema2ruby || {})
+    end
+    def schema_ruby_types
+      @schema_types ||= SCHEMA_TO_RUBY.values.uniq
+    end
+    def java2schema(klass)
+      JAVA_TO_SCHEMA[klass]
+    end
+    def schema2ruby(type)
+      @schema2ruby[type]
+    end
+    def java2ruby(klass)
+      schema2ruby(java2schema(klass))
+    end
+  end
+end

data/lib/jaxb2ruby/version.rb ADDED

@@ -0,0 +1,3 @@
+module JAXB2Ruby
+  VERSION = "0.0.1"
+end

data/lib/jaxb2ruby/xjc.rb ADDED

@@ -0,0 +1,59 @@
+require "tmpdir"
+require "cocaine"
+module JAXB2Ruby
+  class XJC  # :nodoc:
+    CONFIG = File.join(File.dirname(__FILE__), "config.xjb")
+    # https://github.com/thoughtbot/cocaine/issues/24
+    Cocaine::CommandLine.runner = Cocaine::CommandLine::BackticksRunner.new
+    def initialize(schema, options = {})
+      @schema = schema
+      @options = options
+      setup_tmpdirs
+    end
+    def execute
+      xjc
+      javac
+      @classes
+    end
+    private
+    def setup_tmpdirs
+      @tmproot = Dir.mktmpdir
+      @classes = File.join(@tmproot, "classes")
+      @sources = File.join(@tmproot, "source")
+      [@classes, @sources].each { |dir| Dir.mkdir(dir) }
+    rescue IOErorr, SystemCallError => e
+      raise Error, "error creating temp directories: #{e}"
+    end
+    def xjc
+      options = @schema.end_with?(".wsdl") || @options[:wsdl] ? "-wsdl " : ""
+      options << "-extension -npa -d :sources :schema -b :config"
+      options << @options[:jvm].map { |opt| " -J#{opt}" }.join(" ") if @options[:jvm]
+      line = Cocaine::CommandLine.new("xjc", options)
+      line.run(:schema => @schema, :sources => @sources, :config => CONFIG)
+    rescue Cocaine::ExitStatusError => e
+      raise Error, "xjc execution failed: #{e}"
+    rescue Cocaine::CommandNotFoundError => e
+      raise command_not_found("xjc")
+    end
+    def javac
+      files = Dir[ File.join(@sources, "**/*.java") ]
+      line = Cocaine::CommandLine.new("javac", "-d :classes :files")
+      line.run(:classes => @classes, :files => files)
+    rescue Cocaine::ExitStatusError => e
+      raise Error, "javac execution failed: #{e}"
+    rescue Cocaine::CommandNotFoundError => e
+      raise command_not_found("javac")
+    end
+    def command_not_found(cmd)
+      Error.new("#{cmd} command not found, is it in your PATH enviornment variable?")
+    end
+  end
+end

data/lib/templates/happymapper.erb ADDED

@@ -0,0 +1,39 @@
+<%- require "templates/util/happymapper" -%>
+require "happymapper"
+<%- @class.requires.each do |mod| -%>
+require "<%= mod %>"
+<%- end -%>
+<%= @class.module.map { |mod| "module #{mod}" }.join " " %>
+<%= @class.outter_class.map { |klass| "class #{klass}" }.join "; " %>
+class <%= @class.basename %> <%= "< #{@class.superclass}" if @class.superclass %>
+  include HappyMapper
+  <%- [@class.element].concat(@class.element.children).map { |e| e.namespace }.compact.uniq.each do |ns| -%>
+    register_namespace "<%= ns.prefix %>", "<%= ns %>"
+  <%- end -%>
+  <%- if @class.element.root? && @class.element.namespace -%>
+    namespace "<%= @class.element.namespace.prefix %>"
+  <%- end -%>
+  tag "<%= @class.element.local_name %>"
+  <%- @class.element.children.each do |e| -%>
+    <% next if e.type == :ID || e.type == :IDREF %>
+    <%= accessor_method(e) %> :<%= e.accessor %>, <%= type_name(e) %>, :tag => "<%= e.local_name %>", :namespace => <%= namespace(e.namespace) %>
+  <%- end -%>
+  <%- if @class.element.text? -%>
+    content :content
+  <%- end -%>
+  <% @class.element.attributes.each do |attr| %>
+      attribute :<%= attr.accessor %>, <%= type_name(attr) %>, :tag => "<%= attr.local_name %>", :namespace => <%= namespace(attr.namespace) %>
+  <% end %>
+end
+<%= @class.outter_class.map { "end" }.join " " %>
+<%= @class.module.map { "end" }.join " " %>

data/lib/templates/roxml.erb ADDED

@@ -0,0 +1,42 @@
+<%- require "templates/util/roxml" -%>
+require "roxml"
+<%- @class.requires.each do |mod| -%>
+require "<%= mod %>"
+<%- end -%>
+<%= @class.module.map { |mod| "module #{mod}" }.join " " %>
+<%= @class.outter_class.map { |klass| "class #{klass}" }.join "; " %>
+class <%= @class.basename %> <%= "< #{@class.superclass}" if @class.superclass %>
+  include ROXML
+  <%= namespace_map(@class) %>
+  xml_name "<%= @class.element.name %>"
+  <%- @class.element.children.each do |e| -%>
+    <% if e.array? %>
+      xml_accessor <%= accessor_name(e) %>, :as => <%= type_name(e) %>, :from => "<%= e.name %>", :required => <%= e.required? %>
+    <%- elsif unsupported_type?(e.type) -%>
+      xml_accessor <%= accessor_name(e) %>, :from => "<%= e.name %>", :required => <%= e.required? %>
+    <%- else -%>
+      xml_accessor <%= accessor_name(e) %>, :as => <%= type_name(e) %>, :from => "<%= e.name %>", :required => <%= e.required? %>
+    <%- end -%>
+  <%- end -%>
+  <%- if @class.element.text? -%>
+    xml_accessor :content, :from => ".", :required => <%= @class.element.required? %>
+  <%- end -%>
+  <% @class.element.attributes.each do |attr| %>
+    <%- if unsupported_type?(attr.type) -%>
+      xml_accessor <%= accessor_name(attr) %>, :from => "@<%= attr.name %>", :required => <%= attr.required? %>
+    <% else %>
+      xml_accessor <%= accessor_name(attr) %>, :as => <%= type_name(attr) %>, :from => "@<%= attr.name %>", :required => <%= attr.required? %>
+    <% end %>
+  <% end %>
+end
+<%= @class.outter_class.map { "end" }.join " " %>
+<%= @class.module.map { "end" }.join " " %>

data/lib/templates/ruby.erb ADDED

@@ -0,0 +1,44 @@
+<%- accessor = lambda { |node| node.accessor.tr("?", "") }; order = lambda { |nodes| nodes.sort_by { |n| n.name } } %>
+<%- @class.requires.each do |mod| -%>
+require "<%= mod %>"
+<%- end -%>
+<%= @class.module.map { |mod| "module #{mod}" }.join " " %>
+<%= @class.outter_class.map { |klass| "class #{klass}" }.join "; " %>
+class <%= @class.basename %> <%= "< #{@class.superclass}" if @class.superclass %>
+  <%- if @class.element.children.any? %>
+      # Elements
+    <%- order[@class.element.children].each do |attr| -%>
+      attr_accessor :<%= accessor[attr] %>
+    <%- end -%>
+  <% end %>
+  <%- if @class.element.attributes.any? %>
+      # Attributes
+    <%- order[@class.element.attributes].each do |attr| -%>
+      attr_accessor :<%= accessor[attr] %>
+    <%- end -%>
+  <%- end -%>
+  <%- nodes = order[@class.element.children + @class.element.attributes] %>
+  def initialize(attributes = nil)
+    attributes ||= {}
+    <% nodes.each do |node| %>
+      <%- if node.respond_to?(:array?) && node.array? -%>
+        @<%= accessor[node] %> = Array(attributes[:<%= accessor[node] %>]).dup unless attributes[:<%= accessor[node] %>].nil?  <%# should these always ret an array? %>
+      <%- else -%>
+        @<%= accessor[node] %> = attributes[:<%= accessor[node] %>]
+      <%- end -%>
+    <%- end -%>
+  end
+  def inspect
+    sprintf "#<%%s:0x%x <%= nodes.map { |node| "@#{accessor[node]}=%s" }.join(", ") %>>", self.class.name, object_id, <%= nodes.map { |node| "@#{accessor[node]}.inspect" }.join(", ") %>
+  end
+end
+<%= @class.outter_class.map { "end" }.join " " %>
+<%= @class.module.map { "end" }.join " " %>

data/lib/templates/util/happymapper.rb ADDED

@@ -0,0 +1,26 @@
+def accessor_method(node)
+  if node.array?
+    "has_many"
+  elsif node.type.to_s.include?("::")  # Class with namespace?
+    "has_one"
+  else
+    "element"
+  end
+end
+# HappyMapper quirk: we need to return nil if there's no namespace, otherwise the parent element's
+# namespace will be used in XPath searches
+def namespace(ns)
+  ns.blank? ? "nil" : %|"#{ns.prefix}"|
+end
+def type_name(node)
+  case node.type
+    when :boolean
+      "Boolean"
+    when "Object"
+      "String"
+    else
+      node.type
+  end
+end

data/lib/templates/util/roxml.rb ADDED

@@ -0,0 +1,29 @@
+UNSUPPORTED_TYPES = [:ID, :IDREF, :boolean, "String", "Object"]
+def unsupported_type?(type)
+  UNSUPPORTED_TYPES.include?(type)
+end
+def namespace_map(klass)
+  ns = [klass.element].concat(klass.element.children).map { |e| e.namespace }.compact.uniq
+  return unless ns.any?
+  map = "xml_namespaces "
+  map << ns.map { |e| sprintf('"%s" => "%s"', e.prefix, e) }.join(", ")
+end
+def type_name(node)
+  name = unsupported_type?(node.type) ? "" : node.type.dup
+  # May be an attribute node
+  if node.respond_to?(:array?) && node.array?
+    name.prepend "["
+    name.concat  "]"
+  end
+  name
+end
+def accessor_name(node)
+  name = ":#{node.accessor}"
+  name << "?" if node.type == :boolean
+  name
+end

data/spec/converter_spec.rb ADDED

@@ -0,0 +1,213 @@
+require "spec_helper"
+require "jaxb2ruby/type_util"
+describe JAXB2Ruby::Converter do
+  it "creates ruby classes" do
+    classes = convert("address")
+    classes.size.must_equal(2)
+    hash = class_hash(classes)
+    hash["Address"].must_be_instance_of(JAXB2Ruby::RubyClass)
+    hash["Address"].name.must_equal("Com::Example::Address")
+    hash["Address"].module.must_equal("Com::Example")
+    hash["Address"].basename.must_equal("Address")
+    hash["Address"].outter_class.must_be_nil
+    hash["Address"].superclass.must_be_nil
+    hash["Recipient"].must_be_instance_of(JAXB2Ruby::RubyClass)
+    hash["Recipient"].name.must_equal("Com::Example::Recipient")
+    hash["Recipient"].module.must_equal("Com::Example")
+    hash["Recipient"].basename.must_equal("Recipient")
+    hash["Recipient"].superclass.must_be_nil
+    hash["Recipient"].outter_class.must_be_nil
+  end
+  it "creates inner classes from complex anonymous types" do
+    hash = class_hash(convert("types"))
+    hash["NestedClass"].must_be_instance_of(JAXB2Ruby::RubyClass)
+    hash["NestedClass"].name.must_equal("Com::Example::Types::Types::NestedClass")
+    hash["NestedClass"].module.must_equal("Com::Example::Types")
+    hash["NestedClass"].outter_class.must_equal("Types")
+    hash["NestedClass"].basename.must_equal("NestedClass")
+  end
+  it "creates superclasses from complex extension bases" do
+    hash = class_hash(convert("types"))
+    hash["TextSubType"].must_be_instance_of(JAXB2Ruby::RubyClass)
+    hash["TextSubType"].name.must_equal("Com::Example::Types::TextSubType")
+    hash["TextSubType"].superclass.must_equal("Com::Example::Types::TextType")
+  end
+  it "creates an element for each class" do
+    classes = convert("address")
+    hash = class_hash(classes)
+    hash["Address"].element.must_be_instance_of(JAXB2Ruby::Element)
+    hash["Address"].element.name.must_match(/\Ans\d+:Address\z/)
+    hash["Address"].element.local_name.must_equal("Address")
+    hash["Address"].element.namespace.must_equal("http://example.com")
+    hash["Recipient"].element.must_be_instance_of(JAXB2Ruby::Element)
+    hash["Recipient"].element.local_name.must_equal("Recipient")
+    hash["Recipient"].element.name.must_match(/\Ans\d+:Recipient\z/)
+  end
+  it "creates the right child elements for each class' element" do
+    classes = convert("address")
+    hash = class_hash(classes)
+    elements = class_hash(hash["Address"].element.children)
+    elements.size.must_equal(5)
+    %w[House Street Town County Country].each do |name|
+      elements[name].must_be_instance_of(JAXB2Ruby::Element)
+      elements[name].accessor.must_equal(name.underscore)
+      elements[name].type.must_equal("String")
+    end
+    elements = class_hash(hash["Recipient"].element.children)
+    elements.size.must_equal(2)
+    %w[FirstName LastName].each do |name|
+      elements[name].must_be_instance_of(JAXB2Ruby::Element)
+      elements[name].accessor.must_equal(name.underscore)
+      elements[name].type.must_equal("String")
+    end
+  end
+  it "creates the right attributes for each class" do
+    classes = class_hash(convert("address"))
+    classes["Address"].element.attributes.size.must_equal(2)
+    hash = class_hash(classes["Address"].element.attributes)
+    attr = hash["PostCode"]
+    attr.name.must_equal("PostCode")
+    attr.local_name.must_equal("PostCode")
+    attr.accessor.must_equal("post_code")
+    attr.type.must_equal("String")
+    attr = hash["State"]
+    attr.name.must_equal("State")
+    attr.local_name.must_equal("State")
+    attr.accessor.must_equal("state_code")
+    attr.type.must_equal("String")
+    classes["Recipient"].element.attributes.must_be_empty
+  end
+  it "detects classes that are a root xml element" do
+    classes = class_hash(convert("types"))
+    classes["Types"].element.root?.must_equal(true)
+    classes["NestedClass"].element.root?.must_equal(false)
+  end
+  it "detects types that are nillable" do
+    classes = class_hash(convert("types"))
+    nodes = node_hash(classes["Types"].element)
+    nodes["nillable"].nillable?.must_equal(true)
+    nodes["element"].nillable?.must_equal(false)
+  end
+  it "detects classes that are arrays" do
+    classes = class_hash(convert("types"))
+    nodes = node_hash(classes["Types"].element)
+    nodes["idrefs"].array?.must_equal(true)
+    nodes["idrefs"].type.must_equal("Object")
+    nodes["anyType"].must_be_instance_of(JAXB2Ruby::Element)
+    nodes["anyType"].array?.must_equal(false)
+  end
+  it "detects classes that contain text nodes" do
+    classes = class_hash(convert("types"))
+    classes["Types"].element.text?.must_equal(false)
+    classes["TextType"].element.text?.must_equal(true)
+  end
+  it "detects elements that are required" do
+    classes = class_hash(convert("address"))
+    required = node_hash(classes["Recipient"].element).select { |_, v| v.required? }
+    required.size.must_equal(2)
+    required.must_include("FirstName")
+    required.must_include("LastName")
+    required = node_hash(classes["Address"].element).select { |_, v| v.required? }
+    required.size.must_equal(4)
+    %w[House Street Town PostCode].each { |attr| required.must_include(attr) }
+  end
+  it "detects attributes that are required" do
+    classes = class_hash(convert("address"))
+    required = classes["Recipient"].element.attributes.select { |_, v| v.required? }
+    required.must_be_empty
+    required = class_hash(classes["Address"].element.attributes).select { |_, v| v.required? }
+    required.size.must_equal(1)
+    required.first.must_include("PostCode")
+  end
+  it "detects element defaults" do
+    classes = class_hash(convert("address"))
+    defaults = class_hash(classes["Recipient"].element.children).reject { |_, v| v.default.nil? }
+    defaults.must_be_empty
+    defaults = class_hash(classes["Address"].element.children).reject { |_, v| v.default.nil? }
+    defaults.size.must_equal(1)
+    defaults.must_include("Country")
+    defaults["Country"].default.must_equal("US")
+  end
+  it "detects attribute defaults" do
+    skip "No all XJC implementations support attribute defaults... but we do"
+  end
+  describe "given a namespace to module mapping" do
+    let(:mod)   { "A::Namespace" }
+    let(:nsmap) { { "http://example.com" => mod } }
+    it "converts elements in the given namespace to the classes in the given module" do
+      hash = class_hash(convert("address", :namespace => nsmap))
+      hash["Address"].must_be_instance_of(JAXB2Ruby::RubyClass)
+      hash["Address"].name.must_equal("#{mod}::Address")
+      hash["Address"].module.must_equal(mod)
+      hash["Address"].basename.must_equal("Address")
+    end
+  end
+  describe "given an XML Schema type to Ruby type mapping" do
+    let(:typemap) { {
+        "anySimpleType" => "My::Type",
+        "boolean" => "TrueClass"
+     } }
+    # describe "elements without a mapping" do
+    # it "does not convert them" do
+    # end
+    # end
+    describe "elements with a mapping" do
+      it "converts them to the given classes" do
+        classes = class_hash(convert("types", :typemap => typemap))
+        nodes = node_hash(classes["Types"].element)
+        typemap.each do |xsd, ruby|
+          nodes[xsd].must_be_instance_of(JAXB2Ruby::Element)
+          nodes[xsd].type.must_equal(ruby)
+        end
+      end
+    end
+  end
+  describe "XML schema to ruby data type mapping" do
+    let(:nodes) {
+      classes = class_hash(convert("types"))
+      node_hash(classes["Types"].element)
+    }
+    # TODO: nillablePrimitiveArray
+    JAXB2Ruby::TypeUtil::SCHEMA_TO_RUBY.each do |xsd, ruby|
+      it "maps the schema type #{xsd} to the ruby type #{ruby}" do
+        # xsd type is also the accessor name
+        nodes[xsd].must_be_instance_of(JAXB2Ruby::Element)
+        nodes[xsd].type.must_equal(ruby)
+      end
+    end
+  end
+end