RubyGems - rails_on_rails - Versions diffs - 0.0.9 - Mend

rails_on_rails 0.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

checksums.yaml +7 -0
data/README.md +149 -0
data/bin/rails_on_rails +5 -0
data/lib/autogenerators/bash_commands/generate_controller.sh +1 -0
data/lib/autogenerators/bash_commands/generate_model.sh +1 -0
data/lib/autogenerators/bash_commands/install_rspec.sh +1 -0
data/lib/autogenerators/generator_templates/application_record.txt +8 -0
data/lib/autogenerators/generator_templates/controller.txt +14 -0
data/lib/autogenerators/generator_templates/test_rspec_controller.txt +169 -0
data/lib/autogenerators/generator_templates/test_seeder.txt +45 -0
data/lib/autogenerators/handlers/controller.rb +28 -0
data/lib/autogenerators/handlers/initialize_api_docs.rb +24 -0
data/lib/autogenerators/handlers/initialize_global_controller.rb +7 -0
data/lib/autogenerators/handlers/initialize_rspec.rb +23 -0
data/lib/autogenerators/handlers/test_rspec_controller.rb +16 -0
data/lib/autogenerators/handlers/test_seeder.rb +16 -0
data/lib/autogenerators/rails_templates/api_documentation.rake +181 -0
data/lib/autogenerators/rails_templates/auth_helper.rb +73 -0
data/lib/autogenerators/rails_templates/documentation/index.html.erb +121 -0
data/lib/autogenerators/rails_templates/documentation/layout.html.erb +14 -0
data/lib/autogenerators/rails_templates/documentation_controller.rb +139 -0
data/lib/autogenerators/rails_templates/global_controller.rb +411 -0
data/lib/autogenerators/rails_templates/seeds.rb +91 -0
data/lib/constants/cli_constants.rb +56 -0
data/lib/constants/options.rb +61 -0
data/lib/rails_on_rails.rb +124 -0
data/lib/utils/rails_methods.rb +9 -0
metadata +111 -0

data/lib/autogenerators/rails_templates/documentation/layout.html.erb ADDED Viewed

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Automatic API Docs</title>
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+    <%= stylesheet_link_tag    'application', media: 'all', 'data-turbolinks-track': 'reload' %>
+    <%= javascript_include_tag 'application', 'data-turbolinks-track': 'reload' %>
+    <style>.flex-respond-row {display: flex !important;flex-direction: column !important;}@media (min-width: 992px) {.flex-respond-row {display: flex !important;flex-direction: row !important;}}.card-shadow {box-shadow: 0 7px 14px 0 rgba(50,50,93,.1), 0 3px 6px 0 rgba(0,0,0,.07);}.cursor-pointer{ cursor: pointer !important; }</style>
+  </head>
+  <body style="width: 100%; overflow-x: hidden;">
+    <%= yield %>
+  </body>
+</html>

data/lib/autogenerators/rails_templates/documentation_controller.rb ADDED Viewed

@@ -0,0 +1,139 @@
+class DocumentationController < ApplicationController
+  def index
+    @allRoutes = allRoutes
+    render template: 'documentation/index', layout: 'documentation'
+  end
+  private
+  def allRoutes
+    rails_routes = Rails.application.routes.routes.map do |e|
+      route = e.path.spec.to_s.split('(')[0]
+      verb = e.defaults[:action]
+      method = e.verb
+      { method: method, route: route, verb: verb }
+    end.reject do |e|
+      first_path = e[:route].split('/')[1].to_s
+      first_path == 'rails' || first_path == 'assets' || first_path == 'documentation' || first_path == 'cable'
+    end
+    model_lookup = {}
+    description_lookup = {}
+    Dir.foreach("#{Rails.root}/app/models") do |model_path|
+      model, file_suffix = model_path.split('.')
+      if model && file_suffix
+        model_lookup[model.to_sym] = model.to_s
+      end
+    end
+    rails_routes.map do |r|
+      camelCased = ''
+      camelCased += r[:method].downcase
+      method = r[:method]
+      route = r[:route]
+      verb = r[:verb]
+      tempRoute = r[:route]
+      params = []
+      tempRoute.split('/').each do |line|
+        cap = line[0]
+        if cap == ':'
+          line[0] = ''
+          params.push(line)
+          ln = ''
+          line.split('-').each do |l|
+            ln += l.capitalize
+          end
+          camelCased += ln.capitalize + 'Param'
+        else
+          ln = ''
+          line.split('-').each do |l|
+            ln += l.capitalize
+          end
+          camelCased += ln.capitalize
+        end
+      end
+      routeHeader = ''
+      submitButtonColor = ''
+      if method == 'GET'
+        routeHeader = 'bg-success text-white'
+        submitButtonColor = 'btn btn-outline-success'
+      elsif method == 'POST'
+        routeHeader = 'bg-info text-white'
+        submitButtonColor = 'btn btn-outline-info'
+      elsif method == 'PATCH'
+        routeHeader = 'bg-warning text-white'
+        submitButtonColor = 'btn btn-outline-warning'
+      elsif method == 'PUT'
+        routeHeader = 'bg-warning text-white'
+        submitButtonColor = 'btn btn-outline-warning'
+      elsif method == 'DELETE'
+        routeHeader = 'bg-danger text-white'
+        submitButtonColor = 'btn btn-outline-danger'
+      end
+      route_path = route.split('/')
+      route_models = route_path.each_with_object([]) do |e, acc|
+        modal_name = e.underscore.singularize
+        if model_lookup[modal_name.to_sym]
+          acc.push(modal_name.classify.constantize)
+        end
+        acc
+      end
+      description = []
+      if route_models.length > 0
+        model = route_models.last
+        attrbute_keys = model.columns
+        if !description_lookup[model.name.to_sym]
+          include_assocations = model.reflect_on_all_associations.map(&:name).map { |e| "'#{e}'" }.join(",\n")
+          include_description = "Include Querystring options are: [#{include_assocations}]. \n"
+          where_description = "Where Querystring options are: [#{attrbute_keys.map { |e| "'#{e.name}:#{e.type}-value-type>'" }.join(", ")}]. \n"
+          like_description = "Like Querystring options are: [#{attrbute_keys.map { |e| "'#{e.name}:<#{e.type}-value-type>'" }.join(", ")}]. \n"
+          order_description = "Order Querystring options are: [#{attrbute_keys.map { |e| "'#{e.name} ASC'" }.concat(attrbute_keys.map { |e| "'#{e.name} DESC'" }).join(", \n")}]. \n"
+          body_params_description = "Available body params are: #{attrbute_keys.map { |e| e.name }.reject { |e| e == 'id' || e == 'created_at' || e == 'updated_at' }.map { |e| "'#{e}'" }.join(', ')}"
+          description_lookup[model.name.to_sym] = {
+            include_description: include_description,
+            where_description: where_description,
+            like_description: like_description,
+            order_description: order_description,
+            body_params_description: body_params_description,
+          }
+        end
+        include_description ||= description_lookup[model.name.to_sym][:include_description]
+        where_description ||= description_lookup[model.name.to_sym][:where_description]
+        like_description ||= description_lookup[model.name.to_sym][:like_description]
+        order_description ||= description_lookup[model.name.to_sym][:order_description]
+        body_params_description = description_lookup[model.name.to_sym][:body_params_description] || "Available body params are: #{attrbute_keys.map { |e| e.name }.reject { |e| e == 'id' || e == 'created_at' || e == 'updated_at' }.map { |e| "'#{e}'" }.join(', ')}"
+        description.push(include_description) if (verb == 'index' || verb == 'show') && include_description
+        description.push(where_description) if (verb == 'index' || verb == 'show') && where_description
+        description.push(like_description) if verb == 'index' && like_description
+        description.push(order_description) if verb == 'index' && order_description
+        description.push(body_params_description) if verb == 'create'
+        description.push(body_params_description) if verb == 'update'
+      end
+      description.push("Not available") if description.length == 0
+      {
+        method: method,
+        route: route,
+        params: params,
+        middleware: ['Not Available'],
+        routeHeader: routeHeader,
+        submitButtonColor: submitButtonColor,
+        camelCased: camelCased,
+        allowParams: tempRoute.split(':').length > 1,
+        allowBody: method == 'GET' ? false : method != 'DELETE',
+        description: description,
+      }
+    end
+  end
+end

data/lib/autogenerators/rails_templates/global_controller.rb ADDED Viewed

@@ -0,0 +1,411 @@
+class GlobalController < ApplicationController
+  def index
+    options = default_options || {}
+    default_error_handling(handle_pagination(model, options), 200, options)
+  end
+  def show
+    options = default_options || {}
+    default_error_handling(handle_show(model, options), 200, options)
+  end
+  def create
+    default_error_handling(handle_create(model, render_params), 201)
+  end
+  def bulk_create
+    default_error_handling(handle_bulk_create(model, params[:bulk]), 201)
+  end
+  def bulk_csv_create
+    default_error_handling(handle_bulk_create(model, csv_to_json), 201)
+  end
+  def update
+    default_error_handling(handle_update(model, render_params), 200)
+  end
+  def bulk_update
+    default_error_handling(handle_bulk_update(model, params[:bulk]), 200)
+  end
+  def destroy
+    default_error_handling(handle_destroy(model), 204)
+  end
+  def bulk_destroy
+    default_error_handling(handle_bulk_destroy(model, params[:ids]), 204)
+  end
+  def duplicate
+    default_error_handling(handle_duplicate(model), 201)
+  end
+  def handle_duplicate(model_hash, id = nil)
+    associations = model_hash[:model].reflect_on_all_associations.reject { |e| e.is_a?(ActiveRecord::Reflection::BelongsToReflection) }
+    existing = model_hash[:model].find_by(id: id || params[:id])
+    attributes = existing.attributes.symbolize_keys.without(:id, :created_at, :updated_at)
+    as_keyword_lookup = associations.each_with_object({}) do |e, acc|
+      keyword = e && e.options && e.options[:as] ?
+        e.options[:as] : e && e.options && e.options[:source] ?
+        e.options[:source] : false
+      if keyword
+        acc[e.klass.name.to_sym] = (keyword.to_s + '_id').to_sym
+      end
+      acc
+    end
+    parent_model_key = (model_hash[:model].name.to_s.underscore + '_id').to_sym
+    created = model_hash[:model].create(unique_attributes(attributes))
+    all_assocations = associations.select do |e|
+      lookup = e.klass.new.attributes.symbolize_keys
+      as_keyword_lookup[e.klass.name.to_sym] || lookup[parent_model_key]
+    end.map do |e|
+      existing.send(e.name)
+    end
+    all_assocations_with_klass = all_assocations.flat_map { |e| { model: e.klass, data: e } }.reject { |e| e[:data].length == 0 }
+    all_assocations_with_klass.each do |e|
+      model_name = e[:model].name.to_sym
+      polymorphic = as_keyword_lookup[model_name]
+      model_key = polymorphic || (model_hash[:model].name.to_s.underscore + '_id').to_sym
+      model_type = polymorphic || (model_hash[:model].name.to_s.underscore + '_type').to_sym
+      e[:data].each do |element|
+        attrs = element.attributes.symbolize_keys.without(:id, :created_at, :updated_at)
+        if (attrs[model_key] && !polymorphic) || (polymorphic && attrs[model_type] && attrs[model_key] && attrs[model_type] == e[:model].name)
+          attrs[model_key] = created.id
+          e[:model].create(unique_attributes(attrs))
+        end
+      end
+    end
+    created
+  end
+  def handle_pagination(model_hash, options_hash)
+    data = pagination_data_types(model_hash, options_hash)
+    count = pagination_count_type(model_hash, options_hash)
+    { data: data, count: count }
+  end
+  def handle_params(*args)
+    args.each_with_object({}) do |item, acc|
+      if item.is_a?(Array) && item.length > 1 && params[(item[0].to_s + '_id').to_sym]
+        acc[item[0].to_sym] = item[1].find_by(id: params[(item[0].to_s + '_id').to_sym])
+      elsif item.is_a?(String) && params[item.to_sym]
+        acc[item.to_sym] = params[item.to_sym]
+      elsif item.is_a?(Symbol) && params[item]
+        acc[item] = params[item]
+      end
+    end
+  end
+  def handle_show(model_hash, options_hash)
+    show_data_types(model_hash, options_hash)
+  end
+  def handle_create(model_hash, body_params)
+    model_hash[:model].create(body_params)
+  end
+  def handle_bulk_create(model_hash, body_array)
+    model_hash[:model].create(body_array)
+  end
+  def handle_update(model_hash, body_params)
+    model_hash[:model].where(id: params[:id]).update(body_params)
+  end
+  def handle_bulk_update(model_hash, body_hash)
+    model_hash[:model].update(body_hash.keys, body_hash.values)
+  end
+  def handle_destroy(model_hash)
+    model_hash[:model].where(id: params[:id]).delete_all
+  end
+  def handle_bulk_destroy(model_hash, id_array)
+    id_array.split(',').each do |id|
+      model_hash[:model].where(id: id).delete_all
+    end
+    id_array.length
+  end
+  def default_error_handling(data, status_code, opts = {})
+    if status_code == 204 && data
+      render json: data, status: status_code
+    elsif data.respond_to?(:errors) && data.errors.count > 0
+      render json: data.errors, status: 422
+    elsif data
+      if params[:include]
+        sorted_includes = sorted_include_array(params[:include])
+        includes = include_hash(nil, sorted_includes)
+        if data[:data] && data[:count]
+          json = data
+          json[:data] = data[:data].to_json(includes)
+          json[:data] = JSON.parse(json[:data])
+        else
+          json = data.to_json(includes)
+          json = JSON.parse(json)
+        end
+      elsif opts && opts[:include]
+        includes = include_hash(nil, opts[:include])
+        if data[:data] && data[:count]
+          json = data
+          json[:data] = data[:data].to_json(includes)
+          json[:data] = JSON.parse(json[:data])
+        else
+          json = data.to_json(includes)
+          json = JSON.parse(json)
+        end
+      else
+        json = data
+      end
+      if json.is_a?(Array)
+        response = json.map do |obj|
+          black_list_include_keys({}, obj)
+        end
+      elsif json[:data] && json[:count]
+        response = json
+        response[:data] = json[:data].map do |ele|
+          black_list_include_keys({}, ele)
+        end
+      else
+        response = black_list_include_keys({}, json)
+      end
+      render json: response, status: status_code
+    else
+      render json: { error: 'Bad Request' }, status: 400
+    end
+  end
+  private
+  def csv_to_json
+    csv_file = params[:file]
+    text = File.read(csv_file.tempfile)
+    text = text.gsub! "\r", ''
+    lines = text.split("\n")
+    keys = lines[0].split(',')
+    lines.shift
+    rows = lines
+    array = []
+    rows.each do |ln|
+      vals = ln.split(',')
+      hash = {}
+      keys.each_with_index do |key, index|
+        hash[key.to_sym] = vals[index]
+      end
+      array.push(hash)
+    end
+    array
+  end
+  def unique_attributes hash
+    if hash[:key]
+      hash[:key] = append_copy_stamp(hash[:key].to_s)
+    end
+    hash
+  end
+  def append_copy_stamp str
+    str + '_copy_' + DateTime.now.to_s.split('-').join('').split(':').join('').split('T').join('')
+  end
+  def pagination_utils
+    limit = params[:limit] || 25
+    offset = limit * (params[:offset] ? params[:offset].to_i : 0)
+    { limit: limit, offset: offset }
+  end
+  def pagination_data_types(model_hash, options_hash)
+    data = []
+    options_hash ||= {}
+    order = params[:order] || options_hash[:order] || nil
+    where = convert_where_hash(params[:where]) || options_hash[:where] || nil
+    like = convert_like_string(params[:like]) || options_hash[:like] || nil
+    includes = convert_include_array(params[:include]) || options_hash[:include] || nil
+    data = model_hash[:model].limit(pagination_utils[:limit]).offset(pagination_utils[:offset])
+    data = data.where(where) if where
+    data = data.where(*like) if like
+    data = data.includes(*includes) if includes
+    data = data.order(order) if order
+    data.all
+  end
+  def pagination_count_type(model_hash, options_hash)
+    options_hash ||= {}
+    where = options_hash[:where] || convert_where_hash(params[:where]) || nil
+    count = 0
+    count = if where
+              model_hash[:model].where(where).count
+            else
+              model_hash[:model].count
+            end
+    count
+  end
+  def show_data_types(model_hash, options_hash)
+    data = {}
+    id = params[:id]
+    options_hash ||= {}
+    where = convert_where_hash(params[:where]) || options_hash[:where] || nil
+    includes = convert_include_array(params[:include]) || options_hash[:include] || nil
+    includes = includes.is_a?(Array) ? includes : [includes]
+    data = if id.nil?
+             {}
+           elsif options_hash.nil?
+             model_hash[:model].find(id)
+           elsif  includes && where
+             model_hash[:model].where(where).includes(*includes).first
+           elsif  includes
+             model_hash[:model].includes(*includes).find(id)
+           elsif  where
+             model_hash[:model].where(where).first
+           else
+             model_hash[:model].find(id)
+           end
+    data
+  end
+  def convert_like_string(str)
+    if str.nil?
+      nil
+    else
+      where_str = ''
+      types = str.split(',')
+      leng = types.length
+      index = 0
+      type_args = types.map do |e|
+        key, val = e.split(':')
+        index += 1
+        where_str += "#{key} LIKE ?"
+        where_str += ' and ' if index != leng
+        "%#{val}%"
+      end
+      [where_str].concat(type_args)
+    end
+  end
+  def convert_where_hash(str)
+    if str.nil?
+      nil
+    else
+      str.split(',').each_with_object ({}) do |item, acc|
+        key, val = item.split(':')
+        acc[key] = dynamic_types(val)
+      end
+    end
+  end
+  def dynamic_types(str)
+    if str == 'true'
+      true
+    elsif str == 'false'
+      false
+    elsif is_number?(str)
+      str.to_i
+    else
+      str
+    end
+  end
+  def is_number?(string)
+    true if Float(string)
+  rescue StandardError
+    false
+  end
+  def convert_include_array(str)
+    if str.nil?
+      nil
+    else
+      str.split(',').each_with_object ([]) do |item, acc|
+        array = item.split(':')
+        if array.length > 1
+          hash = hash_depth({}, array)
+          acc.push(hash)
+        else
+          key = array[0]
+          acc.push(key.to_sym)
+        end
+      end
+    end
+  end
+  def hash_depth(acc, array)
+    if array.length > 2
+      key = array.shift
+      acc[key.to_sym] = hash_depth({}, array)
+    else
+      key, val = array
+      acc[key.to_sym] = val
+    end
+    acc
+  end
+  def sorted_include_array(str)
+    array = convert_include_array(str)
+    array.sort_by { |a| [(a.is_a?(Hash) ? 1 : 0), a] }
+  end
+  def include_hash(data, hashOrArray)
+    data ||= { include: [] }
+    if hashOrArray.is_a?(Hash)
+      hashOrArray.each do |key, val|
+        hash = {}
+        hash[key.to_sym] = include_hash(nil, val)
+        data[:include].push(hash)
+      end
+    elsif hashOrArray.is_a?(Array)
+      hashOrArray.each { |element| include_hash(data, element) }
+    else
+      data[:include].push(hashOrArray)
+    end
+    data
+  end
+  # Black List all keys for any response
+  # that you do not want in the response
+  def black_list
+    {
+      password: true,
+      password_digest: true,
+      reset_password_token: true
+    }
+  end
+  def black_list_include_keys(acc, collection)
+    collection = collection.as_json
+    collection.each do |k, e|
+      if e.is_a?(Hash)
+        acc[k] = black_list_include_keys({}, e)
+      elsif e.is_a?(Array)
+        acc[k] = e.map do |element|
+          black_list_include_keys({}, element)
+        end
+      elsif !black_list[k.to_sym]
+        acc[k] = e
+      end
+    end
+    acc
+  end
+end