jaxb2ruby 0.0.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dc40239981acd3661e8242ccb2902b59ab764bf7
+  data.tar.gz: af343089fe56230f70396608b57bb5c7165b11a1
+SHA512:
+  metadata.gz: 8bf71fe0df5b94ea3efe7ecd84dc076ada465b339dc20b1c3911ff6144e824329c621df25af4bfb54ca720f7d048aeb636e12eed8356bb52253b9c1bfe7d4efd
+  data.tar.gz: b8b1c81d1c8896ff50a33f85e9df9213f265bbdff09e837bd556b1c8bed16ddf9b1e03190bc283c5ea0af9b4c3134faa562232827a186821b904d50afcd2c31a

data/bin/jaxb2ruby

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+abort "jaxb2ruby must be run with jruby" unless RUBY_PLATFORM == "java"
+
+require "optparse"
+require "fileutils"
+require "yaml"
+require "jaxb2ruby"
+
+include JAXB2Ruby
+
+def mapping_option(option)
+  option.inject({}) do |cfg, opt|
+    if !opt.include?("=")
+      begin
+        cfg.merge!(YAML.load_file(opt))
+      rescue => e
+        abort "cannot load mapping file: #{e}"
+      end
+    else
+      url, klass = opt.split("=", 2)
+      abort "mapping option invalid: #{opt}" if klass.nil? or klass.strip.empty?
+      cfg[url] = klass
+    end
+    cfg
+  end
+end
+
+tmpl = nil
+outdir = "ruby"
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = "usage: #{File.basename($0)} [options] schema"
+
+  opts.on("-c", "--classes=MAP1[,MAP2,...]", Array, "XML Schema type to Ruby class mappings", "MAP can be a string in the form type=class or a YAML file of type/class pairs") do |typemap|
+    options[:typemap] = mapping_option(typemap)
+  end
+
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on("-I", "--include=DIRECTORY", "Add DIRECTORY to the load path, usefull for using custom template helpers") do |path|
+    $LOAD_PATH.unshift(path)
+  end
+
+  opts.on("-J", "--jvm=[ARG1[,ARG2,...]]", Array, "Options to pass to the JVM when calling XJC") do |opt|
+    (options[:jvm] ||= []).concat(opt)
+  end
+
+  opts.on("-n", "--namespace=MAP1[,MAP2,...]", Array, "XML namespace to ruby class mappings", "MAP can be a string in the form namespace=class or a YAML file of namespace/class pairs") do |ns|
+    options[:namespace] = mapping_option(ns)
+  end
+
+  opts.on("-o", "--output=DIRECTORY", "Directory to output the generated ruby classes, defaults to ruby") do |dir|
+    outdir = dir
+  end
+
+  opts.on("-t", "--template=NAME", "Template used to generate the ruby classes", "Can be a path to an ERB template or one of: roxml (default), happymapper, ruby") do |t|
+    tmpl = t
+  end
+
+  opts.on("-v", "--version", "jaxb2ruby version") do
+    puts "v#{JAXB2Ruby::VERSION}"
+    exit
+  end
+
+  opts.on("-w", "--wsdl", "Treat the schema as a WSDL", "Automatically set if the schema has a `.wsdl' extension") do
+    options[:wsdl] = true
+  end
+end
+
+parser.parse!
+schema = ARGV.shift
+abort parser.banner if schema.nil?
+
+begin
+  template = Template.new(tmpl)
+  ruby_classes = Converter.convert(schema, options)
+  puts "outputting classes to #{outdir}"
+  ruby_classes.each do |klass|
+    puts "generating: #{klass.path}"
+    FileUtils.mkdir_p(File.join(outdir, klass.directory))
+    File.open(File.join(outdir, klass.path), "w") { |io| io.puts template.build(klass) }
+  end
+rescue => e
+  puts e.backtrace.join("\n")
+  abort "class generation failed: #{e}"
+end

data/lib/jaxb2ruby.rb

@@ -0,0 +1,15 @@
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string"
+
+require "jaxb2ruby/version"
+require "jaxb2ruby/classes"
+require "jaxb2ruby/converter"
+require "jaxb2ruby/template"
+
+module JAXB2Ruby
+  RUBY_PKG_SEP = "::"
+  JAVA_PKG_SEP = "."
+  JAVA_CLASS_SEP = "$"
+
+  class Error < StandardError; end
+end

data/lib/jaxb2ruby/classes.rb

@@ -0,0 +1,184 @@
+require "forwardable"
+
+module JAXB2Ruby
+  class ClassName < String  # :nodoc:
+    attr :module
+    attr :outter_class  # if java inner class, if any
+    attr :name          # module + outter_class + basename
+    attr :basename
+
+    # Turn a java class name into a ruby class name, with accessors for various parts
+    def initialize(java_name, rubymod = nil)
+      pkg = java_name.split(JAVA_PKG_SEP)
+      pkg = rubymod ? [rubymod, ns2mod(pkg[-1])] : pkg.map { |part| ns2mod(part) }
+
+      parts = pkg.pop.split(JAVA_CLASS_SEP)
+      @basename = parts.pop
+      @outter_class = parts.join(RUBY_PKG_SEP)
+      @module = rubymod || pkg.join(RUBY_PKG_SEP)
+      @name = [@module, @outter_class, @basename].reject(&:empty?).join(RUBY_PKG_SEP)
+
+      super @name
+    end
+
+    private
+    def ns2mod(pkg)
+      pkg.sub(/\A_/, "V").camelize
+    end
+  end
+
+  class Namespace < String # :nodoc:
+    counter = 0
+    @@prefixes = Hash.new { |h,ns|  h[ns] = "ns#{counter+=1}".freeze }
+
+    attr :name
+    attr :prefix
+
+    def initialize(name)
+      @name   = name
+      @prefix = @@prefixes[name]
+      super
+    end
+  end
+
+  class Node
+    attr :type
+    attr :name
+    attr :local_name
+    attr :namespace
+    attr :accessor
+    attr :default
+
+    def initialize(name, options = {})
+      @name = @local_name = name
+
+      @accessor = (options[:accessor] || name).underscore
+      # If this conflicts with a Java keyword it will start with an underscore
+      @accessor.sub!(/\A_/, "")
+
+      @namespace = options[:namespace]
+      @name = sprintf "%s:%s", @namespace.prefix, @local_name if @namespace
+
+      @default = options[:default]
+      @required = !!options[:required]
+      @type = options[:type]
+
+      # TODO: this isn't used. Future plans?
+      @array = !!options[:array]
+      @hash = false
+
+      # Uhhhh, I think this might need some revisiting, esp. with xsd:enumeration
+      if @type.is_a?(Array)
+        @accessor = @accessor.pluralize
+
+        if @type.one?
+          @array = true
+          @type = @type.shift
+        else
+          @hash = true
+        end
+      end
+    end
+
+    def hash?
+      @hash
+    end
+
+    def array?
+      @array
+    end
+
+    def required?
+      @required
+    end
+  end
+
+  class Attribute < Node; end
+
+  class Element < Node
+    attr :children
+    attr :attributes
+
+    def initialize(name, options = {})
+      super
+      @text = !!options[:text]
+      @root = !!options[:root]
+      @nillable = !!options[:nillable]
+      @children = options[:children] || []
+      @attributes = options[:attributes] || []
+    end
+
+    def nillable?
+      @nillable
+    end
+
+    def root?
+      @root
+    end
+
+    def text?
+      @text
+    end
+  end
+
+  class RubyClass
+    extend Forwardable
+
+    attr :module
+    attr :outter_class
+    attr :superclass
+    attr :element
+
+    def_delegators :@type, :name, :basename, :to_s
+
+    def initialize(type, element, dependencies = nil, superclass = nil)
+      @type = type
+      @element = element
+      @dependencies = dependencies || []
+      @superclass = superclass
+
+      @module = @type.module.dup unless @type.module.empty?
+      @outter_class = @type.outter_class.dup unless @type.outter_class.empty?
+
+      [@module, @outter_class].each do |v|
+        v.extend Enumerable
+
+        # v may be NilClass
+        def v.each(&block)
+          ( nil? ? [] : split(RUBY_PKG_SEP) ).each(&block)
+        end
+      end
+    end
+
+    def filename
+      "#{basename.underscore}.rb"
+    end
+
+    def directory
+      File.dirname(path)
+    end
+
+    # This class's path, for passing to +require+.
+    # <code>Foo::Bar::OneTwo</code> will be turned into <code>foo/bar/one_two</code>.
+    #
+    def path
+      @path ||= make_path(@module.to_a.concat(outter_class.to_a).push(filename))
+    end
+
+    # Paths for all of this class's dependencies, for passing to +require+.
+    #
+    def requires
+      # p @element
+      # p @module
+      #     @dependencies.each { |e| p e }
+      # p "-" * 20
+
+      @requires ||= @dependencies.map { |e| make_path(e.split(RUBY_PKG_SEP)) }.sort.uniq
+    end
+
+    private
+    def make_path(modules)
+      modules.map { |name| name.underscore }.join("/")
+    end
+  end
+end

data/lib/jaxb2ruby/config.xjb

@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<jxb:bindings version="1.0"
+              xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+              xmlns:jxb="http://java.sun.com/xml/ns/jaxb"
+              xmlns:xjc="http://java.sun.com/xml/ns/jaxb/xjc"
+              jxb:extensionBindingPrefixes="xjc">
+    <jxb:globalBindings>
+      <!--
+           * Creates a type instead of a JAXBElement for xsd:choice elements
+           * Pluralizes names (we do this anyways in the Ruby code)
+      -->
+      <xjc:simple />
+      <!-- No inherritance when creating elements with a restriction base type -->
+      <!-- <xjc:treatRestrictionLikeNewType /> -->
+    </jxb:globalBindings>
+</jxb:bindings>

data/lib/jaxb2ruby/converter.rb

@@ -0,0 +1,250 @@
+require "find"
+require "fileutils"
+require "java"
+
+require "jaxb2ruby/xjc"
+require "jaxb2ruby/type_util"
+
+module JAXB2Ruby
+  class Converter # :nodoc:
+    XML_NULL = "\u0000"
+    XML_ANNOT_DEFAULT = "##default"
+
+    def self.convert(schema, options = {})
+      new(schema, options).convert
+    end
+
+    def initialize(schema, options = {})
+      raise ArgumentError, "cannot access schema: #{schema}" unless File.file?(schema) and File.readable?(schema)
+      @xjc = XJC.new(schema, :wsdl => !!options[:wsdl], :jvm => options[:jvm])
+
+      @namespace = options[:namespace] || {}
+      raise ArgumentError, "namespace mapping must be a Hash" unless @namespace.is_a?(Hash)
+
+      @typemap = TypeUtil.new(options[:typemap])
+    end
+
+    def convert
+      create_java_classes
+      create_ruby_classes
+    end
+
+    private
+    def create_java_classes
+      @classes = @xjc.execute
+    end
+
+    def create_ruby_classes
+      java_classes = find_java_classes(@classes)
+      raise Error, "no classes were generated from the schema" if java_classes.empty?
+
+      $CLASSPATH << @classes unless $CLASSPATH.include?(@classes)
+      extract_classes(java_classes)
+    rescue IOError, SystemCallError => e
+      raise Error, "failed to generate ruby class: #{e}"
+    end
+
+    def find_java_classes(root)
+      # Without this, parent dir removal below could leave "/" at the start of a non-root path
+      # why do we need exapand though..?
+      root = File.expand_path(root) << "/" unless root.end_with?("/")
+      classes = []
+
+      Find.find(root) do |path|
+        if File.file?(path) && File.extname(path) == ".class"
+          path[root] = ""   # Want com/example/Class not root/com/example/Class
+          classes << path
+        end
+      end
+
+      classes.map { |path| java_name_from_path(path) }
+    end
+
+    def java_name_from_path(path)
+      klass = path.split(%r{/}).join(".")
+      klass[%r{\.class\Z}] = ""
+      klass
+    end
+
+    def extract_namespace(annot)
+      ns = annot.namespace
+      Namespace.new(ns) unless ns.blank? or ns == XML_ANNOT_DEFAULT
+    end
+
+    def find_namespace(klass)
+      annot = klass.annotation(javax.xml.bind.annotation.XmlRootElement.java_class) || klass.annotation(javax.xml.bind.annotation.XmlType.java_class)
+      return unless annot
+
+      # if klass is an inner class the namespace will be on the outter class (enclosing_class).
+      annot.namespace == XML_ANNOT_DEFAULT && klass.enclosing_class ?
+        find_namespace(klass.enclosing_class) :
+        annot.namespace
+    end
+
+    def translate_type(klass)
+      # Won't work for extract_class() as it expects an instance but this should be split anyways
+      return "Object" if klass.java_kind_of?(java.lang.reflect.WildcardType)
+
+      type = @typemap.java2ruby(klass.name)
+      return type if type
+      return "String" if klass.enum?
+
+      # create_class_name(klass)
+      modname = @namespace[find_namespace(klass)]
+      ClassName.new(klass.name, modname)
+    end
+
+    def resolve_type(field)
+      return :ID if field.annotation_present?(javax.xml.bind.annotation.XmlID.java_class)
+      return :IDREF if field.annotation_present?(javax.xml.bind.annotation.XmlIDREF.java_class)
+
+      annot = field.get_annotation(javax.xml.bind.annotation.XmlSchemaType.java_class)
+      return @typemap.schema2ruby(annot.name) if annot.respond_to?(:name)
+
+      # Limited type checking here (but still maybe too much? it's a tad ugly)
+      # should be good enough for List<JAXBElement<Object>> and its variants
+      if field.type.name == "java.util.List"
+        resolved_type = []
+        type = field.generic_type
+
+        if type.java_kind_of?(java.lang.reflect.ParameterizedType)
+          type = type.actual_type_arguments.first
+
+          if type.java_kind_of?(java.lang.reflect.ParameterizedType)
+            resolved_type << translate_type(type.actual_type_arguments.first)
+          # elsif type.java_kind_of?(java.lang.reflect.WildcardType)
+          #   type.get_upper_bounds.each do |lower|
+          #   end
+          #   type.get_lower_bounds.each do |upper|
+          #   end
+          else
+            resolved_type << translate_type(type)
+          end
+        end
+
+        return resolved_type
+      end
+
+      translate_type(field.type)
+    end
+
+    # Create a RubyClass for the given Java class.
+    def extract_class(klass)
+      # Here we expect type to be a ClassName but translate_type can return a String!
+      # type = create_class_name(klass)
+      type = translate_type(klass)
+      element = extract_element(klass)
+
+      dependencies = []
+      #dependencies << type.parent_class if type.parent_class
+
+      superclass = nil
+      if klass.superclass.name != "java.lang.Object"
+        # create_class_name(klass.superclass)
+        superclass = translate_type(klass.superclass)
+        dependencies << superclass
+      end
+
+      (element.children + element.attributes).each do |node|
+        # If a node's type isn't predefined, it must be an XML mapped class
+        dependencies << node.type if !@typemap.schema_ruby_types.include?(node.type)
+      end
+      #p "-" * 20
+
+      RubyClass.new(type, element, dependencies, superclass)
+    end
+
+    # Create elements and attributes from the given Java class' fields
+    def extract_elements_nodes(klass)
+      nodes = { :attributes => [], :children => [] }
+
+      klass.declared_fields.each do |field|
+        if field.annotation_present?(javax.xml.bind.annotation.XmlValue.java_class) || field.annotation_present?(javax.xml.bind.annotation.XmlMixed.java_class)
+          nodes[:text] = true
+          next if field.annotation_present?(javax.xml.bind.annotation.XmlValue.java_class)
+        end
+
+        childopts = { :type => resolve_type(field), :accessor => field.name }
+        #childopts[:type] = type # unless Array(type).first == "Object"
+        childname = childopts[:accessor]
+
+        if annot = field.get_annotation(javax.xml.bind.annotation.XmlElement.java_class)    ||
+                   field.get_annotation(javax.xml.bind.annotation.XmlElementRef.java_class) ||
+                   field.get_annotation(javax.xml.bind.annotation.XmlAttribute.java_class)
+
+          childopts[:namespace] = extract_namespace(annot)
+          childopts[:required] = annot.respond_to?(:required?) ? annot.required? : false
+          childopts[:nillable] = annot.respond_to?(:nillable?) ? annot.nillable? : false
+
+          childname = annot.name if annot.name != XML_ANNOT_DEFAULT
+
+          # Not all implementations support default values for attributes
+          if annot.respond_to?(:default_value)
+            childopts[:default] = annot.default_value == XML_NULL ? nil : annot.default_value
+          end
+        end
+
+        if field.annotation_present?(javax.xml.bind.annotation.XmlAttribute.java_class)
+          nodes[:attributes] << Attribute.new(childname, childopts)
+        else
+          nodes[:children] << Element.new(childname, childopts)
+        end
+      end
+
+      nodes
+    end
+
+    # Create an element from a Java class, turning its fields into elements and attributes
+    def extract_element(klass)
+      #p klass
+      options = extract_elements_nodes(klass)
+
+      if annot = klass.get_annotation(javax.xml.bind.annotation.XmlRootElement.java_class)
+        name = annot.name
+        options[:root] = true
+      end
+
+
+
+
+      if name.blank?
+        annot = klass.get_annotation(javax.xml.bind.annotation.XmlType.java_class)
+        name  = annot.name
+      end
+
+      name = klass.name if name.blank?
+      name = name.split(JAVA_CLASS_SEP).last # might be an inner class
+      # Should grab annot.prop_order
+      # annot = klass.get_annotation(javax.xml.bind.annotation.XmlType.java_class)
+      # annot.prop_order are java props here we have element names
+      # element.elements.sort_by! { |e| annot.prop_order.index }
+      options[:namespace] = extract_namespace(annot)
+
+      #p "name2 #{name}"
+      #p options
+      e=Element.new(name, options)
+      #p e.name
+      #p e.local_name
+      #p e.namespace
+      #p "-" * 20
+      e
+    end
+
+    def valid_class?(klass)
+      # Skip Enum for now, maybe forever!
+      # TODO: make sure this is a legit class else we can get a const error.
+      # For example, if someone uses a namespace that xjc translates into a /javax?/ package
+      !klass.enum? && klass.annotation_present?(javax.xml.bind.annotation.XmlType.java_class)
+    end
+
+    def extract_classes(java_classes)
+      ruby_classes = []
+      java_classes.each do |name|
+        klass = Java.send(name).java_class.to_java
+        next unless valid_class?(klass)
+        ruby_classes << extract_class(klass)
+      end
+      ruby_classes
+    end
+  end
+end