soybean 1.0.0 → 2.0.0

data/VERSION

@@ -1 +1 @@
-1.0.0
+2.0.0

data/bin/soybean

@@ -10,13 +10,21 @@ require 'soybean'
 class Soybean::CLI < Thor
   include Thor::Actions
 
-  desc "classes file_path.xsd", "Generate Ruby classes from XSD"
+  desc "types file_path.xsd", "Generate Ruby classes for xsd-schema from file_path.xsd"
   method_options :quiet => :boolean, :force => :boolean
-
-  def classes(location, destination = 'types')
-    action Soybean::Actions::GenerateClasses.new(self, location, destination, options)
+  def types(location, destination = '.')
+    Soybean::Generators::TypesGenerator.new(URI.parse(location)).generate do |filename, content|
+      create_file File.join(destination, filename), content, options
+    end
   end
 
+  desc "service [PATH_TO_WSDL] [DESTINATION_DIR]", "Generate Ruby classes from WSDL"
+  method_options :quiet => :boolean, :force => :boolean
+  def service(wsdl, destination_dir)
+    Soybean::Generators::ServiceGenerator.new(destination_dir, wsdl).generate do |filename, content|
+      create_file filename, content, options
+    end
+  end
 end
 
 Soybean::CLI.start

data/lib/soybean.rb

@@ -1,11 +1,14 @@
+require 'active_support/core_ext/string/inflections'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/class'
+require 'active_support/core_ext/array/grouping'
 require 'active_support/deprecation'
 require 'active_support/dependencies'
+require 'active_support/dependencies/autoload'
+
 ActiveSupport::Dependencies.autoload_paths << File.absolute_path(File.join(File.dirname(__FILE__), '..', 'vendor/soap4r'))
 ActiveSupport::Dependencies.autoload_paths << File.absolute_path(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 module Soybean
-  # Thor actions
-  module Actions
-    autoload :GenerateClasses, 'soybean/actions/generate_classes'
-  end
+  extend ActiveSupport::Autoload
 end

data/lib/soybean/complex_type.rb

@@ -0,0 +1,46 @@
+module Soybean
+  class ComplexType
+    class_attribute :attributes, :instance_reader => true, :instance_writer => true
+    self.attributes = []
+
+    class << self
+      def attr_accessor(*attrs)
+        self.attributes += attrs
+        super
+      end
+    end
+
+    def initialize(*args)
+      hash = args.extract_options!
+      if args.empty?
+        init_from_hash(hash)
+      else
+        init_from_array(args)
+      end
+    end
+
+    private
+
+    # @param hash [Hash]
+    def init_from_hash(hash)
+      check_arguments_number!(hash)
+      hash.each do |key, val|
+        self.send key.to_sym, val
+      end
+    end
+
+    # @param arry [Array]
+    def init_from_array(arry)
+      check_arguments_number! arry
+      attributes.each_with_index do |key, i|
+        self.send "#{key}=".to_sym, arry.at(i)
+      end
+    end
+
+    def check_arguments_number!(args)
+      if args.size != attributes.size
+        raise ArgumentError, "wrong number of arguments(#{args.size} for #{attributes.size})"
+      end
+    end
+  end
+end

data/lib/soybean/encoded_mapping_registry_creator.rb

@@ -0,0 +1,32 @@
+module Soybean
+  class EncodedMappingRegistryCreator < WSDL::SOAP::EncodedMappingRegistryCreator
+
+    def initialize(definitions, name_creator, modulepath, defined_const, cache)
+      @cache = cache
+      super(definitions, name_creator, modulepath, defined_const)
+    end
+
+    private
+
+    def dump_entry(regname, var)
+      if @cache.key?(var[:class])
+        ''
+      else
+        @cache[var[:class]] = true
+        "#{regname}.register(\n  " +
+            [
+                dump_entry_item(var, :class),
+                dump_entry_item(var, :soap_class),
+                dump_entry_item(var, :schema_name, :qname),
+                dump_entry_item(var, :schema_type, :qname),
+                dump_entry_item(var, :is_anonymous),
+                dump_entry_item(var, :schema_basetype, :qname),
+                dump_entry_item(var, :schema_qualified),
+                dump_entry_item(var, :schema_element),
+                dump_entry_item(var, :schema_attribute)
+            ].compact.join(",\n  ") +
+            "\n)\n"
+      end
+    end
+  end
+end

data/lib/soybean/generators/base_generator.rb

@@ -0,0 +1,11 @@
+module Soybean
+  module Generators
+    module BaseGenerator
+
+      def filename
+        "#{name}.rb"
+      end
+
+    end
+  end
+end

data/lib/soybean/generators/class_generator.rb

@@ -0,0 +1,100 @@
+module Soybean
+  module Generators
+    class ClassGenerator < XSD::CodeGen::ClassDef
+
+      def def_attr(attrname, writable = true, varname = nil)
+        unless safevarname?(varname || attrname)
+          raise ArgumentError.new("#{varname || attrname} seems to be unsafe")
+        end
+        @attrdef << [attrname.underscore, writable, varname.underscore]
+      end
+
+      def def_classvar(var, value)
+        var = var.sub(/\A@@/, "")
+        unless safevarname?(var)
+          raise ArgumentError.new("#{var} seems to be unsafe")
+        end
+        @classvar << [var.underscore, value]
+      end
+
+      def def_method(name, *params)
+        return if name == 'initialize'
+        super name.underscore, *params.map(&:underscore)
+      end
+
+      def dump
+        buf = ""
+        unless @requirepath.empty?
+          buf << dump_requirepath
+        end
+        buf << dump_emptyline unless buf.empty?
+        package = @name.split(/::/)[0..-2]
+        buf << dump_package_def(package) unless package.empty?
+        #buf << dump_comment if @comment
+        buf << dump_class_def
+        spacer = false
+        unless @classvar.empty?
+          spacer = true
+          buf << dump_classvar
+        end
+        unless @const.empty?
+          buf << dump_emptyline if spacer
+          spacer = true
+          buf << dump_const
+        end
+        unless @innermodule.empty?
+          buf << dump_emptyline # always add 1 empty line
+          spacer = true
+          buf << dump_innermodule
+        end
+        unless @code.empty?
+          buf << dump_emptyline if spacer
+          spacer = true
+          buf << dump_code
+        end
+        unless @attrdef.empty?
+          buf << dump_emptyline if spacer
+          spacer = true
+          buf << dump_attributes
+        end
+        buf << accessors
+        unless @methoddef.empty?
+          buf << dump_emptyline if spacer
+          spacer = true
+          buf << dump_methods
+        end
+        buf << dump_class_def_end
+        buf << dump_package_def_end(package) unless package.empty?
+        buf.gsub(/^\s+$/, '')
+      end
+
+      private
+
+      def dump_class_def
+        name = @name.to_s.split(/::/)
+        if @baseclass
+          "class #{name.last} < #{@baseclass}\n"
+        else
+          "class #{name.last} < Soybean::ComplexType\n"
+        end
+      end
+
+      def accessors
+        @attrdef.map do |attrname, *|
+          format("attr_accessor #{attrname.to_sym.inspect}\n", 2)
+        end.join
+      end
+
+      def dump_attribute(attrname, writable, varname)
+        ""
+      end
+
+      def dump_attributes
+        ""
+      end
+
+    end
+  end
+end
+
+

data/lib/soybean/generators/interface_generator.rb

@@ -0,0 +1,31 @@
+require 'wsdl/soap/servant_skelton_creator'
+
+module Soybean
+  module Generators
+    class InterfaceGenerator
+      class InterfaceCreator < WSDL::SOAP::ServantSkeltonCreator
+        def mapped_class_basename(*)
+          (@definitions.name.name.gsub(/Service$/, 'Interface') rescue 'BaseInterface')
+        end
+      end
+
+      include BaseGenerator
+
+      attr_reader :name
+
+      def initialize(wsdl)
+        @wsdl = wsdl
+        @name = (wsdl.name.name.underscore.gsub(/_service$/, '_interface') rescue 'base_interface')
+      end
+
+      def dir
+        'interfaces'
+      end
+
+      def generate
+        InterfaceCreator.new(@wsdl, WSDL::SOAP::ClassNameCreator.new).dump
+      end
+
+    end
+  end
+end

data/lib/soybean/generators/mapping_generator.rb

@@ -0,0 +1,105 @@
+module Soybean
+  module Generators
+    class MappingGenerator
+      class_attribute :mapping_cache, :instance_reader => true, :instance_writer => true
+      self.mapping_cache = Hash.new { |hash, key| hash[key] = {} }
+
+      include BaseGenerator
+      include WSDL::SOAP::ClassDefCreatorSupport
+
+      attr_reader :name
+
+      def initialize(schema)
+        @schema = schema
+        @name = name_from_namespace(schema.targetnamespace)
+        @name_creator = WSDL::SOAP::ClassNameCreator.new
+        @defined_const = {}
+      end
+
+      def dir
+        'mappings'
+      end
+
+      def generate
+        m = ModuleDef.new("#{@name.camelize}")
+
+        varname = 'EncodedRegistry'
+        m.def_code(encoded_creator.dump(varname))
+
+        varname = 'LiteralRegistry'
+        m.def_code(literal_creator.dump(varname))
+
+        @defined_const.each do |ns, tag|
+          m.def_const(tag, dq(ns))
+        end
+
+        registry = ModuleDef.new("Mappings", [m])
+        registry.def_require("soap/mapping")
+        registry.def_code('EncodedRegistry ||= ::SOAP::Mapping::EncodedRegistry.new')
+        registry.def_code('LiteralRegistry ||= ::SOAP::Mapping::LiteralRegistry.new')
+
+        if block_given?
+          yield File.join(dir, filename), registry.dump
+        else
+          registry.dump
+        end
+      end
+
+      def literal_creator
+        LiteralMappingRegistryCreator.new(@schema, @name_creator, 'Types', @defined_const, mapping_cache[:literal])
+      end
+
+      def encoded_creator
+        EncodedMappingRegistryCreator.new(@schema, @name_creator, 'Types', @defined_const, mapping_cache[:encoded])
+      end
+
+      def name_from_namespace(ns)
+        name = URI.parse(ns).path.split('/').delete_if { |part| part.empty? || part == 'type' }.last
+        (name || 'base').underscore.gsub(/_service$/, '')
+      end
+
+      class ModuleDef < XSD::CodeGen::ModuleDef
+        def initialize(name, modules = [])
+          super(name)
+          @innermodule = modules
+        end
+
+        def dump
+          buf = ""
+          unless @requirepath.empty?
+            buf << dump_requirepath
+          end
+          buf << dump_emptyline unless buf.empty?
+          package = @name.split(/::/)[0..-2]
+          buf << dump_package_def(package) unless package.empty?
+          buf << dump_comment if @comment
+          buf << dump_module_def
+          spacer = false
+          unless @const.empty?
+            buf << dump_emptyline if spacer
+            spacer = true
+            buf << dump_const
+          end
+          unless @code.empty?
+            buf << dump_emptyline if spacer
+            spacer = true
+            buf << dump_code
+          end
+          unless @innermodule.empty?
+            buf << dump_emptyline # always add 1 empty line
+            spacer = true
+            buf << dump_innermodule
+          end
+          unless @methoddef.empty?
+            buf << dump_emptyline if spacer
+            spacer = true
+            buf << dump_methods
+          end
+          buf << dump_module_def_end
+          buf << dump_package_def_end(package) unless package.empty?
+          buf.gsub(/^\s+$/, '')
+        end
+      end
+    end
+  end
+end

data/lib/soybean/generators/model_generator.rb

@@ -0,0 +1,23 @@
+module Soybean
+  module Generators
+    class ModelGenerator
+      include BaseGenerator
+
+      attr_reader :name
+
+      def initialize(wsdl)
+        @wsdl = wsdl
+        @name = (wsdl.name.name.underscore rescue 'base')
+      end
+
+      def dir
+        'models'
+      end
+
+      def generate
+        "class %s < %sInterface\nend" % [@name.camelize, @name.camelize.gsub(/Service$/,'')]
+      end
+
+    end
+  end
+end

data/lib/soybean/generators/service_generator.rb

@@ -0,0 +1,48 @@
+module Soybean
+  module Generators
+    class ServiceGenerator
+      attr_reader :path, :wsdl_location, :wsdl
+
+      def initialize(path, wsdl)
+        @path, @wsdl_location = Pathname.new(path), wsdl
+        @wsdl = import_wsdl
+        @schemes = @wsdl.importedschema.keys
+      end
+
+      def schemes
+        @schemes.map { |url| TypesGenerator.new(url) }
+      end
+
+      def generate
+        (schemes + mappings + interface + model).map do |generator|
+          yield path.join(generator.dir, generator.filename), generator.generate
+        end
+      end
+
+      def mappings
+        schemes.map { |gen| MappingGenerator.new(gen.xsd) }
+      end
+
+      def interface
+        [InterfaceGenerator.new(@wsdl)]
+      end
+
+      def model
+        [ModelGenerator.new(@wsdl)]
+      end
+
+      protected
+
+      def dirs
+        @dirs ||= %w{types mappings models interfaces}.inject(HashWithIndifferentAccess.new) do |dirs, dir|
+          dirs[dir.singularize] = Pathname.new @base.empty_directory(File.join(destination_dir, dir))
+          dirs
+        end
+      end
+
+      def import_wsdl
+        WSDL::Importer.import(@wsdl_location)
+      end
+    end
+  end
+end