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

jaxb2ruby 0.0.1-java

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

@@ -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