genio-parser 0.0.1

data/lib/genio/parser/format/base.rb

@@ -0,0 +1,59 @@
+require 'active_support/all'
+require 'uri'
+require 'open-uri'
+
+module Genio
+  module Parser
+    module Format
+      class Base
+        include Logging
+
+        attr_accessor :files, :services, :data_types, :enum_types, :options, :endpoint
+
+        def initialize(options = {})
+          @options = options
+
+          @files      = Types::Base.new( "#" => "self" )
+          @services   = Types::Base.new
+          @data_types = Types::Base.new
+          @enum_types = Types::Base.new
+        end
+
+        def to_iodocs
+          IODocs.to_iodocs(self)
+        end
+
+        def open(file, options = {})
+          options[:ssl_verify_mode] ||= 0
+          super(file, options)
+        end
+
+        def load_files
+          @load_files ||= []
+        end
+
+        def expand_path(file)
+          if load_files.any? and file !~ /^(\/|https?:\/\/)/
+            parent_file = load_files.last
+            if parent_file =~ /^https?:/
+              file = URI.join(parent_file, file).to_s
+            else
+              file = File.expand_path(file, File.dirname(parent_file))
+            end
+          end
+          file
+        end
+
+        def read_file(file, &block)
+          file = expand_path(file)
+          load_files.push(file)
+          logger.info("GET #{file}")
+          block.call(open(file).read)
+        ensure
+          load_files.pop
+        end
+
+      end
+    end
+  end
+end

data/lib/genio/parser/format/iodocs.rb

@@ -0,0 +1,97 @@
+module Genio
+  module Parser
+    module Format
+      class IODocs < Base
+
+        class << self
+
+          def to_iodocs(schema)
+            { "endpoints" => schema.services.map{|name, service| service_to_iodocs(name, service, schema) } }
+          end
+
+          def service_to_iodocs(name, service, schema)
+            { "name" => name,
+              "methods" => service.operations.map{|name, operation| operation_to_iodocs(name, operation, schema) } }
+          end
+
+          URIPropertyName = /{([^}]+)}/
+          def operation_to_iodocs(name, operation, schema)
+            data = {
+              "Name" => name,
+              "HTTPMethod" => operation.type,
+              "URI" => operation.path.gsub(URIPropertyName,':\1') ,
+              "Required" => "Y",
+              "Type" => "complex",
+              "Parameters" => [],
+              "Description" => operation.description || "" }
+            if operation.parameters
+              data["Parameters"] =
+                operation.parameters.map do |name, property|
+                  property_to_iodocs(name, property.merge( :required => (property.location == "path") ), schema)
+                end
+            end
+            operation.path.scan(URIPropertyName) do |name|
+              if operation.parameters.nil? or operation.parameters[$1].nil?
+                property = Types::Property.new(:type => "string", :required => true)
+                data["Parameters"] << property_to_iodocs($1, property, schema)
+              end
+            end
+            if operation.request_property
+              property  = operation.request_property.merge( :required => true )
+              parameter = property_to_iodocs(property.type, property, schema)
+              data["Parameters"] += [ parameter ]
+              data["RequestContentType"] = "application/json"
+            end
+            data
+          end
+
+          def members_loaded
+            @members ||= {}
+          end
+
+          def members_for_data_type(data_type, schema)
+            return [] if members_loaded[data_type]
+            members_loaded[data_type] = true
+            members = []
+            if data_type.extends and schema.data_types[data_type.extends]
+              members += members_for_data_type(schema.data_types[data_type.extends], schema)
+            end
+            data_type.properties.each{|name, property|
+              unless property.readonly
+                members.push(property_to_iodocs(name, property, schema))
+              end
+            }
+            members_loaded.delete(data_type)
+            members
+          end
+
+          def property_to_iodocs(name, property, schema)
+            if property.attribute and schema.options[:attribute]
+              name = "@#{name}"
+            elsif property.package and schema.options[:namespace]
+              name = "#{property.package}:#{name}"
+            end
+            data = {
+              "Name" => name,
+              "Type" => property.type,
+              "ValidatedClass" => property.type,
+            }
+            data["Description"] = property.description if property.description
+            data["Required"] = "Y" if property.required == true
+            data["Default"] = property.default unless property.default.nil?
+            if property.enum
+              data["Type"] = "enumerated"
+              data["EnumeratedList"] = property.enum
+            elsif schema.data_types[property.type]
+              data["Type"]    = "complex"
+              data["Members"] = members_for_data_type(schema.data_types[property.type], schema)
+              data["Members"] = [ data["Members"] ] if property.array
+            end
+            data
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/genio/parser/format/json_schema.rb

@@ -0,0 +1,207 @@
+require 'json'
+
+module Genio
+  module Parser
+    module Format
+      class JsonSchema < Base
+        include Logging
+
+        # Load schema
+        # == Example
+        #   schema.load("path/to/json_schema.json")
+        #   schema.load("http://example.com/json_schema.json")
+        def load(filename, force = false)
+          if data_types[filename] || (!force and data_types[class_name(filename)])
+            class_name(filename)
+          elsif files[filename]
+            files[filename]
+          else
+            files[filename] = class_name(filename)
+            parse_file(filename)
+          end
+        end
+
+        # Parse Given schema file and return class name
+        def parse_file(filename)
+          klass = class_name(filename)
+          read_file(filename) do |data|
+            data = JSON.parse(data, :object_class => Types::Base, :max_nesting => 100)
+            if data.type == "object" or data.properties or data.type.is_a? Array   # Check the type is object or not.
+              data_types[klass] = {}
+              data_types[klass] = parse_object(data)
+            elsif data.resources                          # Checkout the schema file contains the services or not
+              parse_resource(data)
+            end
+          end
+          klass
+        end
+
+        # Parse object schema
+        def parse_object(data)
+          if data["$ref"]
+            return self.data_types[self.load(data["$ref"], true)]
+          end
+
+          properties = Types::Base.new
+
+          # Parse each properties
+          if data.properties
+            data.properties.each do |name, options|
+              properties[name] = parse_property(name, options)
+            end
+          elsif data.type.is_a?(Array)
+            data.type.each do |object|
+              properties.merge!(parse_object(object).properties)
+            end
+          end
+
+          # Load extends class.
+          if data.extends.is_a? String
+            data.extends = self.load(data.extends)
+          else
+            data.extends = nil
+          end
+
+          # Parse array type
+          if data.items
+            array_type = parse_object(data.items)
+            properties.merge!(array_type.properties)
+            data.extends ||= array_type.extends
+            data.array = true
+          end
+
+          data.properties = properties
+          Types::DataType.new(data)
+        end
+
+        # Parse property.
+        def parse_property(name, data)
+          data.array = true if data.type == "array"
+          data.type  =
+            if data["$ref"]               # Check the type is refer to another schema or not
+              self.load(data["$ref"])
+            elsif data.additionalProperties and data.additionalProperties["$ref"]
+              self.load(data.additionalProperties["$ref"])
+            elsif data.properties # Check the type has object definition or not
+              klass_name = class_name(name)
+              data_types[klass_name] = parse_object(data)
+              klass_name
+            elsif data.type.is_a? Array
+              data.union_types = data.type.map do |type|
+                parse_object(type)
+              end
+              "object"
+            elsif data.items              # Parse array value type
+              array_property = parse_property(name, data.items)
+              array_property.type
+            else
+              data.type                   # Simple type
+            end
+          Types::Property.new(data)
+        rescue => error
+          logger.error error.message
+          Types::Property.new
+        end
+
+        # Parse resource schema
+        def parse_resource(data)
+
+          self.endpoint ||= data.rootUrl
+
+          if data.schemas
+            data.schemas.each do |name, options|
+              data_types[class_name(name)] = true
+            end
+            data.schemas.each do |name, options|
+              data_types[class_name(name)] = parse_object(options)
+            end
+          end
+
+          parse_services(data.resources, data)
+        end
+
+        def parse_services(resources, data)
+          # Parse Resources
+          resources.each do |name, options|
+            service = parse_service(options, data)
+            service.path = File.join(data.servicePath, name)
+            if services[class_name(name)]
+              service.operations.merge!(services[class_name(name)].operations)
+            end
+            services[class_name(name)] = service
+          end
+        end
+
+        # Parse each operation in service
+        def parse_service(data, service)
+          data["methods"] ||= {}
+
+          data["methods"].each do |name, options|
+            options.relative_path = options.path
+            options.path = File.join(service.servicePath, options.path)
+            options.type = options.httpMethod
+            if options.request
+              options.request_property = parse_property("#{name}_request", options.request)
+              options.request = options.request_property.type
+            end
+            if options.response
+              options.response_property = parse_property("#{name}_response", options.response)
+              options.response = options.response_property.type
+            end
+            # Load service parameters
+            if options.parameters.nil? and options.type == "GET"
+              options.parameters = service.parameters
+            end
+          end
+
+          data.operations = data["methods"]
+
+          parse_services(data.resources, service) if data.resources
+
+          Types::Service.new(data)
+        end
+
+        # Update configured ref links
+        def update_ref_paths(data, paths = {})
+          paths.each do |path, replace_path|
+            replace_path = replace_path.sub(/\/?$/, "/")
+            data = data.gsub(/("\$ref"\s*:\s*")#{Regexp.escape(path)}\/?/, "\\1#{replace_path}")
+          end
+          data
+        end
+
+        # Format class name
+        # === Example
+        #   class_name("credit-card") # return "CreditCard"
+        #   class_name("/path/to/payment.json") # return "Payment"
+        def class_name(name)
+          File.basename(name.to_s.gsub(/\#$/, "").gsub(/-/, "_"), ".json").camelcase
+        end
+
+        # Fix file name format
+        def file_name(name)
+          name.to_s.gsub(/-/, "_").underscore
+        end
+
+        # Map operations based on the Request or Response types.
+        def fix_unknown_service
+          new_services = Types::Base.new
+          services.each do |service_name, service|
+            unless data_types[service_name]
+              service.operations.each do |operation_name, operation|
+                if data_types[operation.request]
+                  new_services[operation.request] ||= Types::Base.new( :operations => {} )
+                  new_services[operation.request].operations[operation_name] = operation
+                elsif data_types[operation.response]
+                  new_services[operation.response] ||= Types::Base.new( :operations => {} )
+                  new_services[operation.response].operations[operation_name] = operation
+                end
+              end
+            end
+          end
+          services.merge!(new_services)
+        end
+      end
+    end
+  end
+end

data/lib/genio/parser/format/wadl.rb

@@ -0,0 +1,283 @@
+require "nokogiri"
+
+module Genio
+  module Parser
+    module Format
+      class Wadl < Base
+
+        attr_accessor :current_schema, :namespaces, :attributes, :element_form_defaults
+
+        def load(file)
+          return if self.files[file]
+          self.files[file] = file
+
+          doc = load_doc(file)
+          schema = xslt.transform(doc)
+          schema.remove_namespaces!
+
+          parse_schema(schema)
+        end
+
+        def load_doc(file)
+          logger.info "GET #{file}"
+          document = Nokogiri::XML(open(file).read)
+
+          import_document = document.dup
+          import_document.remove_namespaces!
+
+          import_document.css("schema import").each do |import|
+            if import.attr("schemaLocation")
+              import_file = File.join(File.dirname(file), import.attr("schemaLocation"))
+              logger.info "GET #{import_file}"
+              parent = document.css("definitions types").first
+              if parent and parent.children.first
+                xml = Nokogiri::XML(open(import_file).read)
+                xml.children.each{|element| parent.children.first.before(element) }
+              end
+            end
+          end
+
+          document
+        end
+
+        def xslt
+          @xslt ||= Nokogiri::XSLT(File.read(File.expand_path("../../../../../data/wadl2meta.xsl", __FILE__)))
+        end
+
+        def parse_schema(schema)
+
+          self.current_schema = schema
+
+          self.namespaces ||= Types::Base.new
+          schema.css("properties namespace").map{|namespace|
+            self.namespaces[namespace.text] = namespace.attr("name")
+          }
+
+          self.attributes ||= Types::Base.new
+          schema.css("properties attribute").map{|attribute|
+            self.attributes[attribute.attr("name")] = attribute.text
+          }
+
+          self.element_form_defaults ||= Types::Base.new
+          schema.css("properties elementFormDefault").map{|element|
+            self.element_form_defaults[element.attr("namespace")] = element.text
+          }
+
+          schema.css("elements enum").each do |enum|
+            name = valid_class(enum.attr("name"))
+            type = Types::EnumType.new(enum.attributes.map{|k,v| [k, v.value] })
+            type.values = enum.css("value").map{|element| element.text }
+            self.enum_types[name] = type
+          end
+
+          # Load data_types
+          schema.css("classes class").each do |kls|
+            name  = valid_class(kls.attr("name"))
+            value = parse_data_type(kls, self.namespaces[kls.attr("package")])
+            self.data_types[name] = value
+          end
+
+          # Validate property.type in each data_type
+          self.data_types.values.each do |data_type|
+            data_type.properties.values.each do |property|
+              property.type = valid_type(property.type)
+            end
+          end
+
+          # Set endpoint
+          resources = schema.css("resources").first
+          self.endpoint ||= resources.attr("base") if resources
+
+          # Load service and operations
+          schema.css("resources resource").each do |resource|
+            parse_resource(resource)
+          end
+        end
+
+        def parse_data_type(kls, default_package = nil)
+          attrs = Hash[kls.attributes.map{|key, value| [ key, value.value ] }]
+          data_type = Types::DataType.new(attrs)
+
+          if data_type.package.blank?
+            element = self.current_schema.css("elements element[name=#{data_type.name}]")[0]
+            data_type.package = element.attr("package") if element
+          end
+
+          if kls.css("extends").any?
+            data_type.extends = kls.css("extends").first.attr("name")
+          end
+
+          data_type.properties = {}
+          kls.css("properties property").each do |property|
+            name  = property.attr("name")
+            value = Hash[property.attributes.map{|key, value| [ key, value.value ] }]
+            value["package"] = default_package if default_package and name != "value"
+            data_type.properties[name] = parse_property(value)
+          end
+
+          data_type
+        end
+
+        def get_element(name, level = 0)
+          if name.present?
+             element = self.current_schema.css("elements element[name=#{name}]").first
+             if element and element.attr("name") != element.attr("type") and level > 0
+               get_element(element.attr("type"), level - 1 ) || element
+             else
+               element
+             end
+          end
+        end
+
+        def parse_property(property)
+          property = Types::Property.new(property)
+
+          # Check for complex type
+          if property.ref
+            property.type = valid_type(property.ref)
+          end
+
+          unless property.type
+            element = get_element(property.name)
+            if element
+              property.type = element.attr("type")
+              element_package = self.namespaces[element.attr("package")]
+              property.package = element_package if element_package
+            end
+          end
+
+          if property.type.present? and !current_schema.css("classes class[name=#{property.type}]").first
+            element = get_element(property.type)
+            property.type = element.attr("type") if element and element.attr("type").present?
+          end
+
+          # Array type
+          if property.max == "unbounded" or property.max.to_i > 1
+            property.array = true
+          end
+
+          # Required
+          if property.min and property.min.to_i > 0
+            property.required = true
+          end
+
+          # Description
+          if property.documentation
+            property.description = property.documentation.gsub(/\s+/, " ").strip
+          end
+
+          # Enum
+          if enum_types[property.type]
+            property.enum = enum_types[property.type].values
+          end
+
+          property.attribute = true if property.attrib
+
+          property
+        end
+
+        def parse_resource(resource)
+          resource.css("method").each do |method_object|
+            operation = Types::Operation.new(
+                          :id => method_object.attr("id"),
+                          :type => method_object.attr("name"),
+                          :parameters => {},
+                          :path => resource.attr("path") )
+
+            resource.css("> param").each do |param|
+              operation.parameters[param.attr("name")] =
+                Types::Property.new( :type => valid_type(param.attr("type")), :location => "path" )
+            end
+
+            method_object.css("param").each do |param|
+              operation.parameters[param.attr("name")] =
+                Types::Property.new( :type => valid_type(param.attr("type")) )
+            end
+
+            request = method_object.css("request representation").first
+            if request
+              operation.request_property = operation_property(request)
+              operation.request = operation.request_property.type
+            end
+
+            response = method_object.css("response representation").first
+            if response
+              operation.response_property = operation_property(response)
+              operation.response = operation.response_property.type
+            end
+
+            add_operation(operation)
+            operation
+          end
+        end
+
+        def operation_property(type)
+          property = Types::Property.new(type.attributes.map{|k,v| [k, v.value] })
+          property.type = valid_type(property.element) || "string"
+          element = get_element(property.type)
+          property.type = valid_type(element.attr(:type)) if element and element.attr(:type).present?
+          property
+        end
+
+        def add_operation(operation)
+          path = operation.path.split("/")
+          type =
+            if path[-1] =~ /^{/ and path[-2].present? and self.data_types[valid_class(path[-2])]
+              valid_class(path[-2])
+            elsif path[-2] =~ /^{/ and path[-3].present? and self.data_types[valid_class(path[-3])]
+              valid_class(path[-3])
+            elsif path[-1].present? and path[-1] !~ /^{/ and self.data_types[valid_class(path[-1])]
+              valid_class(path[-1])
+            elsif operation.response and self.data_types[operation.response]
+              operation.response
+            elsif operation.request and self.data_types[operation.request]
+              operation.request
+            else
+              "Service"
+            end
+          if type
+            self.data_types[type] ||= Types::DataType.new( :properties => {} )
+            self.services[type] ||= Types::Service.new( :operations => {} )
+            name = operation_name(operation)
+            self.services[type].operations[name] = operation
+          end
+        end
+
+        private
+
+        def valid_class(name)
+          name.gsub(/-/, "_").camelcase
+        end
+
+        def valid_type(name)
+          if name
+            name = name.gsub(/^.*:/, "")
+            type = valid_class(name)
+            ( data_types[type] || enum_types[type] ) ? type : name
+          end
+        end
+
+        def operation_name(operation)
+          if operation.id
+            operation.id
+          elsif operation.type == "GET"
+            if operation.path =~ /}$/
+              "get"
+            else
+              "list"
+            end
+          elsif operation.type == "DELETE"
+            "delete"
+          elsif operation.path =~ /}\/([^{}]*)$/
+            $1.dup
+          elsif operation.type == "POST"
+            "create"
+          else
+            "update"
+          end
+        end
+
+      end
+    end
+  end
+end