power_api 0.1.0

data/lib/power_api/generator_helper/pagination_helper.rb

@@ -0,0 +1,48 @@
+module PowerApi::GeneratorHelper::PaginationHelper
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :use_paginator
+  end
+
+  def api_pagination_initializer_path
+    "config/initializers/api_pagination.rb"
+  end
+
+  def api_pagination_initializer_tpl
+    <<~API_PAGINATION
+      ApiPagination.configure do |config|
+        # If you have more than one gem included, you can choose a paginator.
+        config.paginator = :kaminari
+
+        # By default, this is set to 'Total'
+        config.total_header = 'X-Total'
+
+        # By default, this is set to 'Per-Page'
+        config.per_page_header = 'X-Per-Page'
+
+        # Optional: set this to add a header with the current page number.
+        config.page_header = 'X-Page'
+
+        # Optional: set this to add other response format. Useful with tools that define :jsonapi format
+        # config.response_formats = [:json, :xml, :jsonapi]
+        config.response_formats = [:jsonapi]
+
+        # Optional: what parameter should be used to set the page option
+        config.page_param do |params|
+          params[:page][:number] if params[:page].is_a?(ActionController::Parameters)
+        end
+
+        # Optional: what parameter should be used to set the per page option
+        config.per_page_param do |params|
+          params[:page][:size] if params[:page].is_a?(ActionController::Parameters)
+        end
+
+        # Optional: Include the total and last_page link header
+        # By default, this is set to true
+        # Note: When using kaminari, this prevents the count call to the database
+        config.include_total = true
+      end
+    API_PAGINATION
+  end
+end

data/lib/power_api/generator_helper/resource_helper.rb

@@ -0,0 +1,33 @@
+module PowerApi::GeneratorHelper::ResourceHelper
+  extend ActiveSupport::Concern
+
+  class Resource
+    include PowerApi::GeneratorHelper::ActiveRecordResource
+
+    def initialize(resource_name)
+      self.resource_name = resource_name
+    end
+  end
+
+  included do
+    attr_reader :resource, :parent_resource
+  end
+
+  def resource=(value)
+    @resource = Resource.new(value)
+  end
+
+  def parent_resource=(value)
+    return if value.blank?
+
+    @parent_resource = Resource.new(value)
+  end
+
+  def resource_attributes=(collection)
+    resource.resource_attributes = collection
+  end
+
+  def parent_resource?
+    !!parent_resource
+  end
+end

data/lib/power_api/generator_helper/routes_helper.rb

@@ -0,0 +1,91 @@
+# rubocop:disable Layout/AlignArguments
+module PowerApi::GeneratorHelper::RoutesHelper
+  extend ActiveSupport::Concern
+
+  included do
+    include PowerApi::GeneratorHelper::VersionHelper
+    include PowerApi::GeneratorHelper::ResourceHelper
+    include PowerApi::GeneratorHelper::TemplateBuilderHelper
+  end
+
+  def routes_path
+    "config/routes.rb"
+  end
+
+  def routes_line_to_inject_new_version
+    return "routes.draw do\n" if first_version?
+
+    "'/api' do\n"
+  end
+
+  def api_version_routes_line_regex
+    /Api::V#{version_number}[^\n]*/
+  end
+
+  def parent_resource_routes_line_regex
+    /#{parent_resource_route_tpl}[^\n]*/
+  end
+
+  def version_route_tpl
+    return first_version_route_tpl if first_version?
+
+    new_version_route_tpl
+  end
+
+  def resource_route_tpl(actions: [], is_parent: false)
+    res = (is_parent ? parent_resource : resource).plural
+    line = "resources :#{res}"
+    line += ", only: [#{actions.map { |a| ":#{a}" }.join(', ')}]" if actions.any?
+    line
+  end
+
+  def parent_route_exist?
+    routes_match_regex?(/#{parent_resource_route_tpl}/)
+  end
+
+  def parent_route_already_have_children?
+    routes_match_regex?(/#{parent_resource_route_tpl}[\W\w]*do/)
+  end
+
+  private
+
+  def resource_route_statements(actions: [])
+    line = "resources :#{resource.plural}"
+    line += ", only: [#{actions.map { |a| ":#{a}" }.join(', ')}]" if actions.any?
+    line
+  end
+
+  def routes_match_regex?(regex)
+    path = File.join(Rails.root, routes_path)
+    File.readlines(path).grep(regex).any?
+  end
+
+  def parent_resource_route_tpl
+    raise PowerApi::GeneratorError.new("missing parent_resource") unless parent_resource?
+
+    "resources :#{parent_resource.plural}"
+  end
+
+  def first_version_route_tpl
+    concat_tpl_statements(
+      "scope path: '/api' do",
+        "api_version(#{api_version_params}) do",
+        "end",
+      "end\n"
+    )
+  end
+
+  def new_version_route_tpl
+    concat_tpl_statements(
+      "api_version(#{api_version_params}) do",
+      "end"
+    )
+  end
+
+  def api_version_params
+    "module: 'Api::V#{version_number}', \
+path: { value: 'v#{version_number}' }, \
+defaults: { format: 'json' }"
+  end
+end
+# rubocop:enable Layout/AlignArguments

data/lib/power_api/generator_helper/rubocop_helper.rb

@@ -0,0 +1,11 @@
+module PowerApi::GeneratorHelper::RubocopHelper
+  extend ActiveSupport::Concern
+
+  def format_ruby_file(path)
+    return unless File.exist?(path)
+
+    options, paths = RuboCop::Options.new.parse(["-a", "-fa", path])
+    runner = RuboCop::Runner.new(options, RuboCop::ConfigStore.new)
+    runner.run(paths)
+  end
+end

data/lib/power_api/generator_helper/simple_token_auth_helper.rb

@@ -0,0 +1,124 @@
+module PowerApi::GeneratorHelper::SimpleTokenAuthHelper
+  extend ActiveSupport::Concern
+
+  class SimpleTokenAuthResource
+    include PowerApi::GeneratorHelper::ActiveRecordResource
+    include PowerApi::GeneratorHelper::ResourceHelper
+
+    def initialize(resource)
+      self.resource_name = resource
+    end
+
+    def authenticated_resource_migration
+      "migration add_authentication_token_to_#{plural} \
+authentication_token:string{30}:uniq"
+    end
+  end
+
+  included do
+    attr_reader :authenticated_resources, :authenticated_resource
+    attr_accessor :owned_by_authenticated_resource
+  end
+
+  def authenticated_resources=(values)
+    @authenticated_resources = values.map { |value| SimpleTokenAuthResource.new(value) }
+  end
+
+  def authenticated_resource=(value)
+    return if value.blank?
+
+    @authenticated_resource = SimpleTokenAuthResource.new(value)
+  end
+
+  def authenticated_resource?
+    !!authenticated_resource
+  end
+
+  def owned_by_authenticated_resource?
+    owned_by_authenticated_resource && authenticated_resource? && !parent_resource?
+  end
+
+  def current_authenticated_resource
+    "current_#{authenticated_resource.snake_case}"
+  end
+
+  def simple_token_auth_method
+    <<-METHOD
+  acts_as_token_authenticatable
+
+    METHOD
+  end
+
+  def simple_token_auth_initializer_path
+    "config/initializers/simple_token_authentication.rb"
+  end
+
+  def simple_token_auth_initializer_tpl
+    <<~INITIALIZER
+      SimpleTokenAuthentication.configure do |config|
+        # Configure the session persistence policy after a successful sign in,
+        # in other words, if the authentication token acts as a signin token.
+        # If true, user is stored in the session and the authentication token and
+        # email may be provided only once.
+        # If false, users must provide their authentication token and email at every request.
+        # config.sign_in_token = false
+
+        # Configure the name of the HTTP headers watched for authentication.
+        #
+        # Default header names for a given token authenticatable entity follow the pattern:
+        #   { entity: { authentication_token: 'X-Entity-Token', email: 'X-Entity-Email'} }
+        #
+        # When several token authenticatable models are defined, custom header names
+        # can be specified for none, any, or all of them.
+        #
+        # Note: when using the identifiers options, this option behaviour is modified.
+        # Please see the example below.
+        #
+        # Examples
+        #
+        #   Given User and SuperAdmin are token authenticatable,
+        #   When the following configuration is used:
+        #     `config.header_names = { super_admin: { authentication_token: 'X-Admin-Auth-Token' } }`
+        #   Then the token authentification handler for User watches the following headers:
+        #     `X-User-Token, X-User-Email`
+        #   And the token authentification handler for SuperAdmin watches the following headers:
+        #     `X-Admin-Auth-Token, X-SuperAdmin-Email`
+        #
+        #   When the identifiers option is set:
+        #     `config.identifiers = { super_admin: :phone_number }`
+        #   Then both the header names identifier key and default value are modified accordingly:
+        #     `config.header_names = { super_admin: { phone_number: 'X-SuperAdmin-PhoneNumber' } }`
+        #
+        # config.header_names = { user: { authentication_token: 'X-User-Token', email: 'X-User-Email' } }
+
+        # Configure the name of the attribute used to identify the user for authentication.
+        # That attribute must exist in your model.
+        #
+        # The default identifiers follow the pattern:
+        # { entity: 'email' }
+        #
+        # Note: the identifer must match your Devise configuration,
+        # see https://github.com/plataformatec/devise/wiki/How-To:-Allow-users-to-sign-in-using-their-username-or-email-address#tell-devise-to-use-username-in-the-authentication_keys
+        #
+        # Note: setting this option does modify the header_names behaviour,
+        # see the header_names section above.
+        #
+        # Example:
+        #
+        #   `config.identifiers = { super_admin: 'phone_number', user: 'uuid' }`
+        #
+        # config.identifiers = { user: 'email' }
+
+        # Configure the Devise trackable strategy integration.
+        #
+        # If true, tracking is disabled for token authentication: signing in through
+        # token authentication won't modify the Devise trackable statistics.
+        #
+        # If false, given Devise trackable is configured for the relevant model,
+        # then signing in through token authentication will be tracked as any other sign in.
+        #
+        # config.skip_devise_trackable = true
+      end
+    INITIALIZER
+  end
+end

data/lib/power_api/generator_helper/swagger_helper.rb

@@ -0,0 +1,463 @@
+# rubocop:disable Metrics/ModuleLength
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Layout/AlignArguments
+module PowerApi::GeneratorHelper::SwaggerHelper
+  extend ActiveSupport::Concern
+
+  included do
+    include PowerApi::GeneratorHelper::VersionHelper
+    include PowerApi::GeneratorHelper::ResourceHelper
+    include PowerApi::GeneratorHelper::SimpleTokenAuthHelper
+    include PowerApi::GeneratorHelper::TemplateBuilderHelper
+  end
+
+  def swagger_helper_path
+    "spec/swagger_helper.rb"
+  end
+
+  def spec_swagger_path
+    "spec/swagger/.gitkeep"
+  end
+
+  def spec_integration_path
+    "spec/integration/.gitkeep"
+  end
+
+  def rswag_ui_initializer_path
+    "config/initializers/rswag-ui.rb"
+  end
+
+  def swagger_schemas_path
+    "spec/swagger/v#{version_number}/schemas/.gitkeep"
+  end
+
+  def swagger_resource_spec_path
+    "spec/integration/api/v#{version_number}/#{resource.plural}_spec.rb"
+  end
+
+  def swagger_version_definition_path
+    "spec/swagger/v#{version_number}/definition.rb"
+  end
+
+  def swagger_resource_schema_path
+    "spec/swagger/v#{version_number}/schemas/#{resource.snake_case}_schema.rb"
+  end
+
+  def rswag_ui_configure_line
+    "Rswag::Ui.configure do |c|\n"
+  end
+
+  def swagger_helper_api_definition_line
+    "config.swagger_docs = {\n"
+  end
+
+  def swagger_definition_line_to_inject_schema
+    /definitions: {/
+  end
+
+  def rswag_ui_initializer_tpl
+    <<~INITIALIZER
+      Rswag::Ui.configure do |c|
+      end
+    INITIALIZER
+  end
+
+  def swagger_helper_tpl
+    <<~SWAGGER
+      require 'rails_helper'
+
+      Dir[::Rails.root.join("spec/swagger/**/schemas/*.rb")].each { |f| require f }
+      Dir[::Rails.root.join("spec/swagger/**/definition.rb")].each { |f| require f }
+
+      RSpec.configure do |config|
+        # Specify a root folder where Swagger JSON files are generated
+        # NOTE: If you're using the rswag-api to serve API descriptions, you'll need
+        # to ensure that it's confiugred to serve Swagger from the same folder
+        config.swagger_root = Rails.root.to_s + '/swagger'
+
+        # Define one or more Swagger documents and provide global metadata for each one
+        # When you run the 'rswag:specs:to_swagger' rake task, the complete Swagger will
+        # be generated at the provided relative path under swagger_root
+        # By default, the operations defined in spec files are added to the first
+        # document below. You can override this behavior by adding a swagger_doc tag to the
+        # the root example_group in your specs, e.g. describe '...', swagger_doc: 'v2/swagger.json'
+        config.swagger_docs = {
+        }
+      end
+    SWAGGER
+  end
+
+  def rswag_ui_swagger_endpoint
+    "  c.swagger_endpoint '/api-docs/v#{version_number}/swagger.json', \
+'API V#{version_number} Docs'\n"
+  end
+
+  def swagger_helper_api_definition
+    content = "    'v#{version_number}/swagger.json' => API_V#{version_number}"
+    content = "#{content}," unless first_version?
+    "#{content}\n"
+  end
+
+  def swagger_definition_tpl
+    <<~DEFINITION
+      API_V#{version_number} = {
+        swagger: '2.0',
+        info: {
+          title: 'API V#{version_number}',
+          version: 'v#{version_number}'
+        },
+        basePath: '/api/v#{version_number}',
+        definitions: {
+        }
+      }
+    DEFINITION
+  end
+
+  def swagger_schema_tpl
+    <<~SCHEMA
+      #{swagger_model_definition_const} = {
+        type: :object,
+        properties: {
+          id: { type: :string, example: '1' },
+          type: { type: :string, example: '#{resource.snake_case}' },
+          attributes: {
+            type: :object,
+            properties: {#{get_swagger_schema_attributes_definitions}
+            },
+            required: [#{get_swagger_schema_attributes_names}
+            ]
+          }
+        },
+        required: [
+          :id,
+          :type,
+          :attributes
+        ]
+      }
+
+      #{swagger_collection_definition_const} = {
+        type: "object",
+        properties: {
+          data: {
+            type: "array",
+            items: { "$ref" => "#/definitions/#{resource.snake_case}" }
+          }
+        },
+        required: [
+          :data
+        ]
+      }
+
+      #{swagger_resource_definition_const} = {
+        type: "object",
+        properties: {
+          data: { "$ref" => "#/definitions/#{resource.snake_case}" }
+        },
+        required: [
+          :data
+        ]
+      }
+    SCHEMA
+  end
+
+  def swagger_definition_entry
+    [
+      "\n    #{resource.snake_case}: #{swagger_model_definition_const},",
+      "\n    #{resource.plural}_collection: #{swagger_collection_definition_const},",
+      "\n    #{resource.snake_case}_resource: #{swagger_resource_definition_const},"
+    ].join
+  end
+
+  def swagger_resource_spec_tpl
+    concat_tpl_statements(
+      "require 'swagger_helper'\n",
+      concat_tpl_statements(
+        spec_tpl_initial_describe_line,
+        spec_tpl_authenticated_resource,
+        spec_tpl_let_parent_resource,
+        spec_tpl_collection_path_statements,
+        spec_tpl_resource_path_statements,
+        "end\n"
+      )
+    )
+  end
+
+  private
+
+  def spec_tpl_initial_describe_line
+    "describe 'API V#{version_number} #{resource.plural_titleized}', \
+swagger_doc: 'v#{version_number}/swagger.json' do"
+  end
+
+  def spec_tpl_authenticated_resource
+    return unless authenticated_resource?
+
+    res_name = authenticated_resource.snake_case
+    concat_tpl_statements(
+      "let(:#{res_name}) { create(:#{res_name}) }",
+      "let(:#{res_name}_email) { #{res_name}.email }",
+      "let(:#{res_name}_token) { #{res_name}.authentication_token }\n"
+    )
+  end
+
+  def spec_tpl_collection_path_statements
+    concat_tpl_statements(
+      "path '/#{spec_tpl_collection_path}' do",
+        spec_tpl_parent_resource_parameter,
+        spec_tpl_authenticated_resource_params,
+        spec_tpl_index,
+        spec_tpl_create,
+      "end\n"
+    )
+  end
+
+  def spec_tpl_collection_path
+    return resource.plural unless parent_resource?
+
+    "#{parent_resource.plural}/{#{parent_resource.id}}/#{resource.plural}"
+  end
+
+  def spec_tpl_resource_path_statements
+    concat_tpl_statements(
+      "path '/#{resource.plural}/{id}' do",
+        spec_tpl_authenticated_resource_params,
+        spec_tpl_let_existent_resource,
+        spec_tpl_show,
+        spec_tpl_update,
+        spec_tpl_destroy,
+      "end\n"
+    )
+  end
+
+  def spec_tpl_let_existent_resource
+    statement = ["let(:existent_#{resource.snake_case}) { create(:#{resource.snake_case}"]
+    load_owner_resource_option(statement)
+
+    concat_tpl_statements(
+      "parameter name: :id, in: :path, type: :integer\n",
+      "#{statement.join(', ')}) }",
+      "let(:id) { existent_#{resource.snake_case}.id }\n"
+    )
+  end
+
+  def spec_tpl_authenticated_resource_params
+    return unless authenticated_resource?
+
+    res_name = authenticated_resource.snake_case
+    concat_tpl_statements(
+      "parameter name: :#{res_name}_email, in: :query, type: :string",
+      "parameter name: :#{res_name}_token, in: :query, type: :string\n"
+    )
+  end
+
+  def spec_tpl_index
+    concat_tpl_statements(
+      "get 'Retrieves #{resource.plural_titleized}' do",
+        "description 'Retrieves all the #{resource.plural}'",
+        "produces 'application/json'\n",
+        "let(:collection_count) { 5 }",
+        "let(:expected_collection_count) { collection_count }\n",
+        "before { #{spec_tpl_index_creation_list} }",
+        "response '200', '#{resource.plural_titleized} retrieved' do",
+          "schema('$ref' => '#/definitions/#{resource.plural}_collection')\n",
+          "run_test! do |response|",
+            "expect(JSON.parse(response.body)['data'].count).to eq(expected_collection_count)",
+          "end",
+        "end\n",
+        spec_tpl_invalid_credentials,
+      "end\n"
+    )
+  end
+
+  def spec_tpl_index_creation_list
+    statement = ["create_list(:#{resource.snake_case}, collection_count"]
+    load_owner_resource_option(statement)
+    statement.join(', ') + ')'
+  end
+
+  def load_owner_resource_option(statement)
+    if parent_resource?
+      statement << "#{parent_resource.snake_case}: #{parent_resource.snake_case}"
+    end
+
+    if owned_by_authenticated_resource?
+      statement << "#{authenticated_resource.snake_case}: #{authenticated_resource.snake_case}"
+    end
+  end
+
+  def spec_tpl_create
+    concat_tpl_statements(
+      "post 'Creates #{resource.titleized}' do",
+        "description 'Creates #{resource.titleized}'",
+        "consumes 'application/json'",
+        "produces 'application/json'",
+        "parameter(name: :#{resource.snake_case}, in: :body)\n",
+        "response '201', '#{resource.snake_case} created' do",
+          "let(:#{resource.snake_case}) do",
+            "{#{resource_params}}",
+          "end\n",
+          "run_test!",
+        "end\n",
+        spec_tpl_create_invalid_attrs_test,
+        spec_tpl_invalid_credentials(with_body: true),
+      "end\n"
+    )
+  end
+
+  def spec_tpl_parent_resource_parameter
+    return unless parent_resource?
+
+    "parameter name: :#{parent_resource.id}, in: :path, type: :integer"
+  end
+
+  def spec_tpl_let_parent_resource
+    return unless parent_resource?
+
+    concat_tpl_statements(
+      "let(:#{parent_resource.snake_case}) { create(:#{parent_resource.snake_case}) }",
+      "let(:#{parent_resource.id}) { #{parent_resource.snake_case}.id }\n"
+    )
+  end
+
+  def spec_tpl_show
+    concat_tpl_statements(
+      "get 'Retrieves #{resource.titleized}' do",
+        "produces 'application/json'\n",
+        "response '200', '#{resource.snake_case} retrieved' do",
+          "schema('$ref' => '#/definitions/#{resource.snake_case}_resource')\n",
+          "run_test!",
+        "end\n",
+        "response '404', 'invalid #{resource.snake_case} id' do",
+          "let(:id) { 'invalid' }",
+          "run_test!",
+        "end\n",
+        spec_tpl_invalid_credentials,
+      "end\n"
+    )
+  end
+
+  def spec_tpl_update
+    concat_tpl_statements(
+      "put 'Updates #{resource.titleized}' do",
+        "description 'Updates #{resource.titleized}'",
+        "consumes 'application/json'",
+        "produces 'application/json'",
+        "parameter(name: :#{resource.snake_case}, in: :body)\n",
+          "response '200', '#{resource.snake_case} updated' do",
+          "let(:#{resource.snake_case}) do",
+            "{#{resource_params}}",
+          "end\n",
+          "run_test!",
+        "end\n",
+        spec_tpl_update_invalid_attrs_test,
+        spec_tpl_invalid_credentials(with_body: true),
+      "end\n"
+    )
+  end
+
+  def spec_tpl_destroy
+    concat_tpl_statements(
+      "delete 'Deletes #{resource.titleized}' do",
+        "produces 'application/json'",
+        "description 'Deletes specific #{resource.snake_case}'\n",
+        "response '204', '#{resource.snake_case} deleted' do",
+          "run_test!",
+        "end\n",
+        "response '404', '#{resource.snake_case} not found' do",
+          "let(:id) { 'invalid' }\n",
+          "run_test!",
+        "end\n",
+        spec_tpl_invalid_credentials,
+      "end\n"
+    )
+  end
+
+  def spec_tpl_invalid_credentials(with_body: false)
+    return unless authenticated_resource?
+
+    authenticated_resource_name = authenticated_resource.snake_case
+    concat_tpl_statements(
+      "response '401', '#{authenticated_resource_name} unauthorized' do",
+        with_body ? "let(:#{resource.snake_case}) { {} }" : nil,
+        "let(:user_token) { 'invalid' }\n",
+        "run_test!",
+      "end\n"
+    )
+  end
+
+  def spec_tpl_update_invalid_attrs_test
+    spec_tpl_create_invalid_attrs_test
+  end
+
+  def spec_tpl_create_invalid_attrs_test
+    return if resource.required_resource_attributes.blank?
+
+    concat_tpl_statements(
+      "response '400', 'invalid attributes' do",
+        "let(:#{resource.snake_case}) do",
+          "{#{invalid_resource_params}}",
+        "end\n",
+        "run_test!",
+      "end\n"
+    )
+  end
+
+  def resource_params
+    attrs = if resource.required_resource_attributes.any?
+              resource.required_resource_attributes
+            else
+              resource.optional_resource_attributes
+            end
+
+    for_each_schema_attribute(attrs) do |attr|
+      "#{attr[:name]}: #{attr[:example]},"
+    end
+  end
+
+  def invalid_resource_params
+    return unless resource.required_resource_attributes.any?
+
+    for_each_schema_attribute([resource.required_resource_attributes.first]) do |attr|
+      "#{attr[:name]}: nil,"
+    end
+  end
+
+  def swagger_model_definition_const
+    "#{resource.upcase}_SCHEMA"
+  end
+
+  def swagger_collection_definition_const
+    "#{resource.upcase_plural}_COLLECTION_SCHEMA"
+  end
+
+  def swagger_resource_definition_const
+    "#{resource.upcase}_RESOURCE_SCHEMA"
+  end
+
+  def get_swagger_schema_attributes_definitions
+    for_each_schema_attribute(resource.resource_attributes) do |attr|
+      opts = ["example: #{attr[:example]}"]
+      opts << "'x-nullable': true" unless attr[:required]
+      opts
+
+      "#{attr[:name]}: { type: :#{attr[:swagger_type]}, #{opts.join(', ')} },"
+    end
+  end
+
+  def get_swagger_schema_attributes_names
+    for_each_schema_attribute(resource.required_resource_attributes) do |attr|
+      ":#{attr[:name]},"
+    end
+  end
+
+  def for_each_schema_attribute(attributes)
+    attributes.inject("") do |memo, attr|
+      memo += "\n"
+      memo += yield(attr)
+      memo
+    end.delete_suffix(",")
+  end
+end
+# rubocop:enable Metrics/ModuleLength
+# rubocop:enable Metrics/MethodLength
+# rubocop:enable Layout/AlignArguments