aries 0.1.0

data/lib/aries.rb

@@ -0,0 +1,28 @@
+require "active_support/core_ext/object/try"
+require "active_support/core_ext/string/inflections"
+require "active_support/core_ext/module/delegation"
+require 'json'
+require 'json_schema'
+require 'erubis'
+require 'thor'
+require 'addressable/template'
+
+require "aries/version"
+require "aries/error"
+require "aries/schema"
+require "aries/resource"
+require "aries/link"
+require "aries/param"
+require "aries/param_type"
+require "aries/generator"
+require "aries/cli"
+
+require "aries/presenters/schema_swift"
+require "aries/presenters/resource_swift"
+require "aries/presenters/link_swift"
+require "aries/presenters/param_swift"
+require "aries/presenters/param_type_swift"
+
+module Aries
+
+end

data/lib/aries/cli.rb

@@ -0,0 +1,19 @@
+module Aries
+
+  class Cli < ::Thor
+
+    option :output, aliases: "-o"
+    option :name, aliases: "-n"
+    option :url,  aliases: "-u"
+    desc "generate SCHEMA_FILE_PATH", "generate api client from schem schema"
+    def generate schema_file
+      Aries::Generator.generate(schema_file, {}.tap { |opt|
+        opt[:output_path] = options[:output] if options[:output]
+        opt[:class_name]  = options[:name]   if options[:name]
+        opt[:base_url]    = options[:url]    if options[:url]
+      })
+    end
+
+  end
+
+end

data/lib/aries/error.rb

@@ -0,0 +1,3 @@
+module Aries
+  class Error < StandardError; end
+end

data/lib/aries/generator.rb

@@ -0,0 +1,94 @@
+module Aries
+
+  class Generator
+
+    def self.generate schema_path, options
+      new(schema_path, options).exec
+    end
+
+    #
+    # @param file_path [String] json schema file path
+    #
+    def initialize schema_path, options ={}
+      @schema_path = schema_path
+      @output_path = options[:output_path] || Dir.pwd
+      @class_name  = options[:class_name]  || "AriesApi"
+      @language    = options[:language]     || "swift"
+      @base_url    = options[:base_url]
+    end
+
+    # @return [Aries::Presenters::SchemaSwift]
+    def schema
+      case @language
+      when "swift"
+        Aries::Presenters::SchemaSwift.new original_schema
+      end
+    end
+
+    # @return [Aries::Schema]
+    def original_schema
+      Schema.new JSON.parse(File.read(@schema_path))
+    end
+
+    # @return [String]
+    def class_name
+      @class_name.camelcase
+    end
+
+    # @return [String]
+    def output_path
+      @output_path
+    end
+
+    # @return [String]
+    def extension
+      case @language
+      when "swift" then "swift"
+      when "java" then "java"
+      end
+     end
+
+    # @return [String]
+    def file_name
+      class_name + "." + extension
+    end
+
+    # @return [String]
+    def base_url
+      @base_url || schema.base_url
+    end
+
+    # @return [Array<Aries::Presenters::ResourceSwift>]
+    def resources
+      schema.resources
+    end
+
+    # @return [String]
+    def template_path
+      File.expand_path("../templates/client.#{@language}.erb", __FILE__)
+    end
+
+    # @return [String]
+    def file_path
+      output_path + "/" + file_name
+    end
+
+    # @return [ERB]
+    def template
+      Erubis::Eruby.new File.read(template_path), trim: true
+    end
+
+    def timestamp
+      Time.now.strftime('%Y/%m/%d')
+    end
+
+    # @return [TrueClass, FalseClass]
+    def exec
+      return puts "File already exists" if File.exist?(file_path)
+      File.write file_path, template.result(binding)
+      true
+    end
+
+  end
+
+end

data/lib/aries/link.rb

@@ -0,0 +1,105 @@
+module Aries
+  class Link
+
+    URL_REGEXP = /\{\(#([%\/a-zA-Z0-9_-]*)\)\}/
+
+    attr_reader :parent
+
+    # @param link [JsonSchema::Schema::Link]
+    def initialize link, parent = nil
+      @link = link
+      @parent = parent
+    end
+
+    # @return [Array<Aries::Param>] Required request parameter
+    def required_params
+      if @link.schema && @link.schema.required && params
+        params.select{|param| @link.schema.required.include? param.name } + url_params
+      else
+        url_params
+      end
+    end
+
+    # @return [Array<Aries::Param>] Optional requrest parameter
+    def optional_params
+      params - required_params
+    end
+
+    # @return [Array<Aries::Param>]
+    def params
+      (prop_params + url_params).uniq
+    end
+
+    # @return [Array<Aries::Param]
+    def prop_params
+      @prop_params ||= if @link.schema && @link.schema.properties
+                         @link.schema.properties.map do |name, definition|
+                           Param.new name, definition, self, type: :prop
+                         end
+                       else
+                         []
+                       end
+    end
+
+    # @return [Array<Aries::Param>]
+    def url_params
+      @url_params ||= href.scan(URL_REGEXP).flatten.map do |param|
+        Param.new param.split('/').last, root_schema.property_by(param), self, type: :url
+      end
+    end
+
+    # @return [TrueClass, FalseClass]
+    def has_params?
+      params.size > 0
+    end
+
+    # @return [String] api client's request method name
+    # @example
+    #   method_name #=> "list"
+    def method_name
+      title.split.join('_').underscore
+    end
+
+    # @return [String] http request method
+    def http_method
+      @link.method.to_s.upcase
+    end
+
+    # @return [String] requrest encode type URL encode or JSON encode used in client
+    def encode
+      case http_method
+      when "GET"
+        "URL"
+      else
+        "JSON"
+      end
+    end
+
+    # @return [String] convert uri template to {resource_name}_{action_name} template
+    def pretty_href
+      href.gsub(URL_REGEXP){|n| "{" + n.scan(/definitions\/([a-zA-Z0-9\-\_]+)/)
+                                       .map{|v| v[0].split('-').join('_') }.join('_').camelize(:lower) + "}"  }
+    end
+
+    # @return [String] url decoded href string
+    def href
+      URI.decode @link.href
+    end
+
+    # @return [String]
+    def title
+      @link.title
+    end
+
+    def inspect
+      return "#<Link title=#{title}>"
+    end
+
+
+    # @return [Aries::Schema] Root schema of link
+    def root_schema
+      @parent.respond_to?(:parent) ? @parent.root_schema : @parent
+    end
+
+  end
+end

data/lib/aries/param.rb

@@ -0,0 +1,75 @@
+module Aries
+
+  class Param
+
+    attr_reader :parent
+
+    def initialize name, definition, parent = nil, options = {}
+      @name = name
+      @definition = definition
+      @parent = parent
+      @param_type = options[:type]
+    end
+
+    def name
+      @name
+    end
+
+    # @return [String] name of param
+    def pretty_name
+      if @param_type == :url && has_resource?
+        "#{@parent.parent.name}_#{name}"
+      else
+        name
+      end
+    end
+
+    # @return [Array<Aries::Param>]
+    def params
+      @definition.properties.map do |name, definition|
+        Aries::Param.new name, definition, self, type: @param_type
+      end
+    end
+
+    # @return [TrueClass, FalseClass] whether contains null or not
+    def optional?
+      @definition.type.detect{|type| type == "null" } != nil
+    end
+
+    # @return [TrueClass, FalseClass] whether contains child parameters
+    def has_children?
+      @definition.type.detect{|type| type == "object" } != nil
+    end
+
+    # @return [Array<Aries::Type>]
+    def type
+      Aries::ParamType.new @definition.type.detect{|type| type != "null"}, self
+    end
+
+    def inspect
+      return "#<Aries::Param name=#{name} >"
+    end
+
+    private
+
+    def param_tree
+      trees = [self]
+      pr = parent
+      while pr.kind_of?(Param)
+        trees.unshift pr
+        pr = pr.parent
+      end
+      trees
+    end
+
+    def has_resource?
+      if parent.kind_of?(Param)
+        parent.has_resource?
+      else
+        parent.respond_to?(:parent) && parent.parent.kind_of?(Resource)
+      end
+    end
+
+  end
+
+end

data/lib/aries/param_type.rb

@@ -0,0 +1,18 @@
+module Aries
+
+  class ParamType
+
+    ALLOWED_TYPES = %w{any array boolean integer number null object string}
+
+    def initialize type, parent = nil
+      @type = type
+      @parent = parent
+    end
+
+    def type
+      @type
+    end
+
+  end
+
+end

data/lib/aries/presenters/link_swift.rb

@@ -0,0 +1,55 @@
+module Aries
+
+  module Presenters
+
+    class LinkSwift
+
+      delegate :http_method, :href, :pretty_href, :encode, :has_params?, to: :original
+
+      # @param link [Aries::Link]
+      def initialize link
+        @link = link
+      end
+
+      # @return [String]
+      def method_name
+        original.method_name.camelcase
+      end
+
+      [:required_params, :optional_params, :params,
+                         :prop_params, :url_params].each do |m|
+        define_method(m) do
+          original.send(m).map{|v| ParamSwift.new v }
+        end
+      end
+
+      # @return [String] params string for template
+      def params_for_method
+        if params.size > 0
+          (required_params.map{|v| "#{v.name}: #{v.param_class}" } +
+            optional_params.map{|v| "#{v.name}: #{v.param_class}? = nil"}).join(', ')
+        else
+          ""
+        end
+      end
+
+      # @return [String] param keys string for template
+      def params_keys
+        if params.size > 0
+          params.map{|v| v.name}.join(',')
+        else
+          ""
+        end
+      end
+
+      private
+
+      def original
+        @link
+      end
+
+    end
+
+  end
+
+end

data/lib/aries/presenters/param_swift.rb

@@ -0,0 +1,41 @@
+module Aries
+
+  module Presenters
+
+    class ParamSwift
+
+      delegate :has_children?, to: :original
+
+      # @param [Aries::Param]
+      def initialize param
+        @param = param
+      end
+
+      def name
+        original.pretty_name.camelize(:lower)
+      end
+
+      def param_class
+        type.param_class
+      end
+
+      def type
+        ParamTypeSwift.new original.type
+      end
+
+      def params
+        original.params.map{|v| ParamSwift.new v }
+      end
+
+      private
+
+      # @return [Aries::Param]
+      def original
+        @param
+      end
+
+    end
+
+  end
+
+end