rails_on_rails 0.0.9 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36958c631c1d24258e9702004ed3508e01cbb96fc73e0a8fc438f144e9e61c3c
-  data.tar.gz: d06ab2bf6e5dcc635cd1b5a9c877456a327cac3d559a2a4e15b7a6c5a9105982
+  metadata.gz: eb3dbb175a9306c55ce2219b84038c0dfbdf4b79b7a3a97f985ec221622ae6da
+  data.tar.gz: 7f2f855bfa4447c615c6320e37cd8139e9fb14b69a1ca14f3bd6f44c2f6ab6a7
 SHA512:
-  metadata.gz: 297087d5e99077cdb55c44498b2e71dded0ceab7fc6d4e50a0de308d08ba9407fc300c85885dd9c8002f08abaa1e58df3f3bb4c04ac9e1d749624a8f713e9659
-  data.tar.gz: a0de593f1c62b04e9f91a7d076f5dd22ca74188ba6407bcc34ef056ef979e376cca6554202845e0b85a8e6540e28de2161e5a86ea5cc97294e5d2d57907ce918
+  metadata.gz: 5835c6bfa33b804955685fdc3793c493c97cf81d636069229af555d44cfe0f5831e9b3b0f7903db80a5441ca20b0d29d4966509f6f64673ab10b73ac80d494e4
+  data.tar.gz: a23a9adcc55b146c9660b35a8034a0c08c0b5fe80539c12427df83b99151c27720f4ab5ca8419dd1901ab226bbc686368a4684cafc3a782842f402fcfc7e6196

data/README.md

@@ -40,7 +40,27 @@ In your `config/routes.rb` add this route for your documentation page
 resources :documentation, only: :index
 ```
 
+You are now free to run the `rails_on_rails model` command which has the same paramters as `rails g model`
+But instead generates a controller for your model with unit tests to test the fully operationality controller after you declare your routes
+and update a model assocations.
+
+## CLI Commands
+Rails on Rails: Command Line Interface to make your life easier.
+=> The Rails on Rails command is 'rails_on_rails'. To blast this project into the fifth dimension.
+=> Use '--help' or '-h on any of the commands listed below for more details.
+
+List of commands:
+=> i - Setup your initial Rails on Rails project
+=> init - Setup your initial Rails on Rails project
+=> model - Generate a new model migration, fully operational controller, and unit tests for that controller
+=> test:seeder - Generate a test seeder for your model
+=> test:spec - Generate a test spec for your controller
+
 ## Generate your CRUD Operations for Index, Show, Create, Update, & Destroy
+The `rails_on_rails model` command which has the same paramters as `rails g model`
+But instead generates a controller for your model with unit tests to test the fully operationality controller after you declare your routes
+and update a model assocations.
+
 ```
 rails_on_rails model <ModelName> <*rails-model-generate-parameters>
 ```
@@ -86,7 +106,7 @@ params[:bulk] = { 1 => { name: 'Luke Skywalker' }, 2 => { name: 'Darth Vader' }
 
 #### Declaring bonus methods in `config/routes.rb`
 ```
-rsources :user, except: [:edit, :new] do 
+resources :user, except: [:edit, :new] do 
     collection do 
         post 'duplicate'
         post 'bulk_create'
@@ -104,7 +124,7 @@ Also setup your file uploads (multipart) to be independent of erb templating
 For custom headers that you may add in the future update the `lib/api_documentation.rake`
 Line 48: is where you can update the needed headers for your axios ajax requests.
 ```
-var csrfHeader = { headers: { 'X-CSRF-Token': null, 'Accept': 'application/json', 'Content-Type': 'application/json' } };
+var csrfHeader = { headers: { 'X-CSRF-Token': null } };
 ```
 
 By default only json formats are unaccept for RESTful API JSON formatting
@@ -147,3 +167,29 @@ Under the 'Param' title
 This dropdown is only used for file uploads by default they are set to JSON
 Use 'Form Data' for file uploads
 
+## RSpec Unit Tests
+
+### Authenicated Routes
+In your support file there is a called auth_helper. auth_helper.rb contains a login method.
+You can enter your own login endpoint here and pass in any needed params with email and password as an example
+so you can test authenicated routes with a JSON Web Token in your headers
+
+### Test Database Seeders
+The database seeders that are generated are a template that work for most types of schemas.
+For custom schemas that may have unique constraints or unique behaviors. You can set a conditional to 
+search for the unique column name and set a value for it to satsify your unique needs.
+
+These seeders are only for your test database with randomized data from faker
+
+### Controller Specs
+The controller spec has tests for the generated controller. After you declare your routes, you can restrict the 
+tests for the routes you declare. The config_routes hash at the top will toggle those tests on or off because on what you set.
+By default all tests are true.
+Tests only cover basic CRUD resources: index, show, create, update, and destroy
+
+## GlobalController
+There are many helpful util functions in the global controller at your deposal.
+You can inherit the GlobalController instead of ApplicationController for your new controllers.
+This gives you both the default Rails controller functionality and all these utils
+
+In the autogeneration we utilize inheritance as much as posssible for cleaner controllers

data/lib/autogenerators/generator_templates/controller.txt

@@ -1,11 +1,7 @@
 class {{ MODEL }}Controller < GlobalController
 
   def model 
-    { model: {{ MODEL }} }
-  end
-
-  def default_options
-    {}
+    {{ MODEL }}
   end
 
   def render_params

data/lib/autogenerators/generator_templates/test_rspec_controller.txt

@@ -16,9 +16,17 @@ RSpec.describe {{ MODEL }}Controller, type: :request do
   created = nil
   created_2 = nil
 
+  before :all do
+    @user = User.first || create(:user_create)
+    @headers = {}.merge(login_user)
+  end
+
   blacklist = {}
   associations = get_associations({{ MODEL }}).reject { |e| blacklist[e.to_sym] }
 
+  count = {{ MODEL }}.count
+
+  pagination = pagination_querystring_checks(count)
   includes = include_querystrings(associations)
   wheres = where_querystrings([
     { id: 1 },
@@ -33,6 +41,7 @@ RSpec.describe {{ MODEL }}Controller, type: :request do
   ])
 
   pagination_querystrings = concat_all_with_default([
+    pagination,
     includes,
     wheres,
     likes,
@@ -45,6 +54,16 @@ RSpec.describe {{ MODEL }}Controller, type: :request do
 
   if config_routes[:index]
     pagination_querystrings.each do |val|
+      querys = parse_qs_value(val)
+
+      if querys[:offset] && querys[:limit]
+        it "Pagination check count" do
+          get "#{route_name}?#{val}", headers: @headers
+          @resp = JSON.parse(response.body)
+          expect(@resp["data"].length).to be <= querys[:limit].to_i
+        end
+      end
+
       it "No Auth: Index: No 500 errors" do
         get "#{route_name}?#{val}"
         expect(response.status).to be < 500
@@ -87,18 +106,18 @@ RSpec.describe {{ MODEL }}Controller, type: :request do
 
   if config_routes[:create]
     it "No Auth: Create: No 500 errors" do
-      post "#{route_name}", params: {}
+      post "#{route_name}", params: {  }
       expect(response.status).to be < 500
     end
 
     it "Create: No 500 errors" do
-      post "#{route_name}", params: {}, headers: @headers
+      post "#{route_name}", params: {  }, headers: @headers
       created = JSON.parse(response.body)
       expect(response.status).to be < 500
     end
 
     it "Create: Body Format" do
-      post "#{route_name}", params: {}, headers: @headers
+      post "#{route_name}", params: {  }, headers: @headers
       @resp = JSON.parse(response.body)
       created_2 = @resp
       @check = @resp.is_a?(Hash)

data/lib/autogenerators/handlers/controller.rb

@@ -1,12 +1,13 @@
 require_relative '../../utils/rails_methods.rb'
 
-MODEL_NAME = ARGV[0]
+SKIP_MODEL = true?(ARGV[0])
+MODEL_NAME = ARGV[1]
 MODEL_PARAMS = ARGV
-MODEL_PARAMS.shift
+2.times { |i| MODEL_PARAMS.shift }
 
 MODEL_SNAKE_CASE = MODEL_NAME.underscore
 
-system("bash #{__dir__}/../bash_commands/generate_model.sh #{MODEL_NAME} #{MODEL_PARAMS.join(' ')}")
+system("bash #{__dir__}/../bash_commands/generate_model.sh #{MODEL_NAME} #{MODEL_PARAMS.join(' ')}") if !SKIP_MODEL
 system("bash #{__dir__}/../bash_commands/generate_controller.sh #{MODEL_SNAKE_CASE} --no-assets --no-view-specs --no-helper")
 
 controller_path = "#{Dir.pwd}/app/controllers/#{MODEL_SNAKE_CASE}_controller.rb"
@@ -18,7 +19,12 @@ length = MODEL_PARAMS.length
 PARAMS_STRING = MODEL_PARAMS.map do |item|
   str = ''
   key, type = item.split(':')
-  str += type == 'references' ? "[:#{key}, " + "#{key.split('_').map(&:capitalize!).join('')}]" : ":#{key}"
+  polymorphoric = false
+  if /references/.match?(type)
+    polymorphoric = /poly/.match?(type)
+    type = 'references'
+  end
+  str += type == 'references' ? "{ key: :#{key}, model: #{key.split('_').map(&:capitalize!).join('')} }" : ":#{key}"
   str
 end.join(', ')
 

data/lib/autogenerators/handlers/test_seeder.rb

@@ -2,13 +2,24 @@ require 'date'
 require_relative '../../utils/rails_methods.rb'
 
 MODEL_NAME = ARGV[0]
+MODEL_PARAMS = ARGV
 MODEL_SNAKE_CASE = MODEL_NAME.underscore
+MODEL_PARAMS.shift
 
 TIMESTAMP = DateTime.now.to_s.split('-').join('').split(':').join('').split('T').join('').slice(0, 14)
 
 controller_path = Dir.pwd + "/db/seedfiles/test/#{TIMESTAMP}_#{MODEL_SNAKE_CASE}.rb"
 template_path = __dir__ + "/../generator_templates/test_seeder.txt"
 
+MODEL_PARAMS.each do |item|
+    key, type = item.split(':')
+    if /references/.match?(type)
+        polymorphoric = /poly/.match?(type)
+        type = 'references'
+        puts "\nPolymorphic associations will require extra safety checks in seeder file.\nCheck readme for more details."
+    end
+end
+
 read_file = File.open(template_path, 'r:UTF-8', &:read)
 
 read_file = read_file.gsub! '{{ MODEL }}', MODEL_NAME

data/lib/autogenerators/rails_templates/api_documentation.rake

@@ -9,7 +9,7 @@ namespace :api_documentation do
         { route: route, method: method }
       end.reject do |e|
         first_path = e[:route].split('/')[1].to_s
-        first_path == 'rails' || first_path == 'assets' || first_path == 'docs' || first_path == 'cable'
+        first_path == 'rails' || first_path == 'assets' || first_path == 'documentation' || first_path == 'cable'
       end
       
       javascriptString = ''

data/lib/autogenerators/rails_templates/auth_helper.rb

@@ -1,73 +1,89 @@
 def login_user
-    # Update your own login authenication endpoint
-    post '/login', params: { email: @user[:email], password: @user[:password] }
-    auth_header = response.headers['Authorization']
-    { Authorization: auth_header }
+  # Update your own login authenication endpoint
+  post '/login', params: { email: @user[:email], password: @user[:password] }
+  auth_header = response.headers['Authorization']
+  { Authorization: auth_header }
+end
+
+def objects_list_to_querystring qs, object
+  querystring = "#{qs}="
+  v = object.map { |key, val| "#{key.to_s}:#{val.to_s}" }.join(',')
+  querystring + v
+end
+
+def parse_qs_value string
+  string.split('&').each_with_object({}) do |e, acc|
+    key, val = e.split('=')
+    acc[key.to_sym] = val
+    acc
   end
-  
-  def objects_list_to_querystring qs, object
-    querystring = "#{qs}="
-    v = object.map { |key, val| "#{key.to_s}:#{val.to_s}" }.join(',')
-    querystring + v
-  end
-  
-  def string_list_to_querystring qs, array
-    array = array.is_a?(Array) ? array : [array]
-    querystring = "#{qs}="
-    v = array.join(',')
-    querystring + v
-  end
-  
-  def string_permuations array
-    index = 0
-    perms = array.each_with_object([]) do |e, acc|
-      index += 1
-      acc.push(array.slice(0, index))
-    end
-    order = perms.each_with_object([]) do |e, acc|
-      acc.push(e.permutation.to_a.map { |d| d.join(',') })
-    end
-    order.each_with_object([]) do |e, acc|
-      acc = acc.concat(e)
-      acc
-    end
-  end
-  
-  def order_options array
-    array.each_with_object([]) do |e, acc|
-      acc.push("#{e} ASC")
-      acc.push("#{e} DESC")
-    end
+end
+
+def pagination_querystring_checks count, init_limit = 3
+  if count < init_limit
+    ["offset=0&limit=1"]
+  else
+    limit = (count/init_limit.to_f).ceil
+    init_limit.times.map { |i| "offset=#{i}&limit=#{limit}" }
+  end  
+end
+
+def string_list_to_querystring qs, array
+  array = array.is_a?(Array) ? array : [array]
+  querystring = "#{qs}="
+  v = array.join(',')
+  querystring + v
+end
+
+def string_permuations array
+  index = 0
+  perms = array.each_with_object([]) do |e, acc|
+    index += 1
+    acc.push(array.slice(0, index))
   end
-  
-  def concat_all_with_default array
-    array.each_with_object(['']) do |e, acc|
-      acc = acc.concat(e)
-      acc
-    end
+  order = perms.each_with_object([]) do |e, acc|
+    acc.push(e.permutation.to_a.map { |d| d.join(',') })
   end
-  
-  def include_querystrings array
-    [''].concat(string_permuations(array).map { |e| string_list_to_querystring('include', e) })
+  order.each_with_object([]) do |e, acc|
+    acc = acc.concat(e)
+    acc
   end
-  
-  def where_querystrings array
-    [''].concat(array.map { |e| objects_list_to_querystring('where', e) })
+end
+
+def order_options array
+  array.each_with_object([]) do |e, acc|
+    acc.push("#{e} ASC")
+    acc.push("#{e} DESC")
   end
-  
-  def like_querystrings array
-    [''].concat(array.map { |e| objects_list_to_querystring('like', e) })
+end
+
+def concat_all_with_default array
+  array.each_with_object(['']) do |e, acc|
+    acc = acc.concat(e)
+    acc
   end
+end
+
+def include_querystrings array
+  [''].concat(string_permuations(array).map { |e| string_list_to_querystring('include', e) })
+end
+
+def where_querystrings array
+  [''].concat(array.map { |e| objects_list_to_querystring('where', e) })
+end
+
+def like_querystrings array
+  [''].concat(array.map { |e| objects_list_to_querystring('like', e) })
+end
+
+def order_querystrings array
+  [''].concat(array.map { |e| string_list_to_querystring('like', e) })
+end
+
+def get_associations model 
+  model.reflect_on_all_associations.map(&:name)
+    .reject do |e|
+      model.reflect_on_association(e).is_a?(ActiveRecord::Reflection::ThroughReflection)
+    end.map { |e| e.to_s }
+end
   
-  def order_querystrings array
-    [''].concat(array.map { |e| string_list_to_querystring('like', e) })
-  end
-  
-  def get_associations model 
-    model.reflect_on_all_associations.map(&:name)
-      .reject do |e|
-        model.reflect_on_association(e).is_a?(ActiveRecord::Reflection::ThroughReflection)
-      end.map { |e| e.to_s }
-  end
-    
-  

data/lib/autogenerators/rails_templates/documentation_controller.rb

@@ -15,73 +15,41 @@ class DocumentationController < ApplicationController
       { 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'
+      first_path == 'rails' || first_path == 'assets' || first_path == 'docs' || 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
+    model_lookup = models_lookup
 
     rails_routes.map do |r|
-      camelCased = ''
-      camelCased += r[:method].downcase
+      camel_cased = r[:method].downcase
       method = r[:method]
       route = r[:route]
       verb = r[:verb]
 
-      tempRoute = r[:route]
+      temp_route = r[:route]
       params = []
 
-      tempRoute.split('/').each do |line|
+      temp_route.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'
+          camel_cased += route_name_convention(line).capitalize + 'Param'
         else
-          ln = ''
-          line.split('-').each do |l|
-            ln += l.capitalize
-          end
-          camelCased += ln.capitalize
+          camel_cased += route_name_convention(line).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
+      color = color_lookup[method.upcase.to_sym] || 'light'
+      route_header = "bg-#{color} text-white"
+      submit_button_color = "btn btn-outline-#{color}"
 
       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.push(modal_name.classify.constantize) if model_lookup[modal_name.to_sym]
         acc
       end
 
@@ -106,18 +74,18 @@ class DocumentationController < ApplicationController
             body_params_description: body_params_description,
           }
         end
+
+        offset_description = "Offset Querystring option is the page you are going to retrieve for pagination \n"
+        limit_description = "Limit Querystring option is the page count for pagination \n"
         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'
+        description = description.concat([where_description, include_description]) if (verb == 'index' || verb == 'show')
+        description = description.concat([order_description, like_description, limit_description, offset_description]) if verb == 'index'
+        description.push(body_params_description) if verb == 'create' || verb == 'update'
       end
 
       description.push("Not available") if description.length == 0
@@ -127,13 +95,38 @@ class DocumentationController < ApplicationController
         route: route,
         params: params,
         middleware: ['Not Available'],
-        routeHeader: routeHeader,
-        submitButtonColor: submitButtonColor,
-        camelCased: camelCased,
-        allowParams: tempRoute.split(':').length > 1,
+        routeHeader: route_header,
+        submitButtonColor: submit_button_color,
+        camelCased: camel_cased,
+        allowParams: temp_route.split(':').length > 1,
         allowBody: method == 'GET' ? false : method != 'DELETE',
         description: description,
       }
     end
   end
+
+  def route_name_convention line
+    line.split('-').inject('') { |acc, l| acc += l.capitalize }
+  end
+
+  def color_lookup 
+    {
+      GET: 'success',
+      POST: 'info',
+      PUT: 'warning',
+      PATCH: 'warning',
+      DELETE: 'danger',
+    }
+  end
+
+  def models_lookup
+    model_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
+    model_lookup
+  end
 end

data/lib/autogenerators/rails_templates/global_controller.rb

@@ -1,73 +1,144 @@
 class GlobalController < ApplicationController
+  # Black List any of these keys from your response
+  def black_list
+    {
+      # response_key: true,
+      password: true,
+      password_digest: true,
+      reset_password_token: true
+    }
+  end
+
+  #  Default declarations
+
+  def model
+    raise StandardError, 'Define a model'
+  end
+
+  def render_params
+    raise StandardError, 'Define your render_params'
+  end
+
+  def default_options
+    {}
+  end
+
+  #  Resource Action Methods
+
   def index
-    options = default_options || {}
-    default_error_handling(handle_pagination(model, options), 200, options)
+    default_error_handling(handle_pagination, 200)
   end
 
   def show
-    options = default_options || {}
-    default_error_handling(handle_show(model, options), 200, options)
+    default_error_handling(handle_show, 200)
   end
 
   def create
-    default_error_handling(handle_create(model, render_params), 201)
+    default_error_handling(handle_create(create_params), 201)
   end
 
   def bulk_create
-    default_error_handling(handle_bulk_create(model, params[:bulk]), 201)
+    default_error_handling(handle_bulk_create(bulk_create_params), 201)
   end
 
   def bulk_csv_create
-    default_error_handling(handle_bulk_create(model, csv_to_json), 201)
+    default_error_handling(handle_bulk_create(bulk_csv_create_params), 201)
   end
 
   def update
-    default_error_handling(handle_update(model, render_params), 200)
+    data = handle_update(update_params)
+    default_error_handling(data[:data], data[:status])
   end
 
   def bulk_update
-    default_error_handling(handle_bulk_update(model, params[:bulk]), 200)
+    default_error_handling(handle_bulk_update(bulk_update_params), 200)
   end
 
   def destroy
-    default_error_handling(handle_destroy(model), 204)
+    default_error_handling(handle_destroy, 204)
   end
 
   def bulk_destroy
-    default_error_handling(handle_bulk_destroy(model, params[:ids]), 204)
+    default_error_handling(handle_bulk_destroy(bulk_delete_params), 204)
   end
 
   def duplicate
-    default_error_handling(handle_duplicate(model), 201)
+    default_error_handling(handle_duplicate, 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
+  # Custom params.permit methods for Global Controller
+
+  def handle_params(*args)
+    args.each_with_object({}) do |item, acc|
+      if item.is_a?(Hash) && !item.empty? && params[(item[:key].to_s + '_id').to_sym]
+        acc[item[:key].to_sym] = item[:model].find_by(id: params[(item[:key].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_bulk_parcode .
+    ams(*args)
+    params[:bulk].map do |element|
+      args.each_with_object({}) do |item, acc|
+        if item.is_a?(Hash) && !item.empty? && element[(item[:key].to_s + '_id').to_sym]
+          acc[item[:key].to_sym] = item[:model].find_by(id: element[(item[:key].to_s + '_id').to_sym])
+        elsif item.is_a?(String) && element[item.to_sym]
+          acc[item.to_sym] = element[item.to_sym]
+        elsif item.is_a?(Symbol) && element[item]
+          acc[item] = element[item]
+        end
       end
-      acc
     end
-    parent_model_key = (model_hash[:model].name.to_s.underscore + '_id').to_sym
-    created = model_hash[:model].create(unique_attributes(attributes))
+  end
+
+  # Default param declarations
+
+  def create_params
+    render_params
+  end
+
+  def update_params
+    render_params
+  end
+
+  def bulk_create_params
+    params[:bulk]
+  end
+
+  def bulk_delete_params
+    params[:ids]
+  end
+
+  def bulk_csv_create_params
+    params[:csv_json]
+  end
+
+  # Handlers for Global Controller methods
+
+  def handle_duplicate(id = nil)
+    associations = model.reflect_on_all_associations.reject { |e| e.is_a?(ActiveRecord::Reflection::BelongsToReflection) }
+    existing = model.find_by(id: id || params[:id])
+    attributes = existing.attributes.symbolize_keys.without(:id, :created_at, :updated_at)
+
+    as_keyword_lookup = association_lookup(associations)
+    parent_model_key = (model.name.to_s.underscore + '_id').to_sym
+    created = 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 }
+    end.map { |e| existing.send(e.name) }
+
+    all_assocations_with_klass = all_assocations.flat_map { |e| { model: e.klass, data: e } }.reject { |e| e[:data].empty? }
     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
+      model_key = polymorphic || (model.name.to_s.underscore + '_id').to_sym
+      model_type = polymorphic || (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)
@@ -79,102 +150,63 @@ class GlobalController < ApplicationController
     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 }
+  def handle_pagination
+    { data: pagination_data_types, count: pagination_count_type }
   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
+  def handle_show
+    show_data_types
   end
 
-  def handle_show(model_hash, options_hash)
-    show_data_types(model_hash, options_hash)
+  def handle_create(body_params)
+    model.create(body_params)
   end
 
-  def handle_create(model_hash, body_params)
-    model_hash[:model].create(body_params)
+  def handle_bulk_create(body_array)
+    model.create(body_array)
   end
 
-  def handle_bulk_create(model_hash, body_array)
-    model_hash[:model].create(body_array)
+  def handle_update(body_params)
+    data = model.where(id: params[:id]).update(body_params)
+    if data.is_a?(Array) && !data.empty?
+      { status: 200, data: data.first }
+    else
+      { status: 400, data: { error: 'Bad Request' } }
+    end
   end
 
-  def handle_update(model_hash, body_params)
-    model_hash[:model].where(id: params[:id]).update(body_params)
+  def handle_bulk_update(body_hash)
+    model.update(body_hash.keys, body_hash.values)
   end
 
-  def handle_bulk_update(model_hash, body_hash)
-    model_hash[:model].update(body_hash.keys, body_hash.values)
+  def bulk_update_params
+    params[:bulk]
   end
 
-  def handle_destroy(model_hash)
-    model_hash[:model].where(id: params[:id]).delete_all
+  def handle_destroy
+    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
+  def handle_bulk_destroy(id_array)
+    id_array.split(',').map { |id| model.where(id: id).delete_all }.length
   end
 
-  def default_error_handling(data, status_code, opts = {})
+  # Querystring Parsing & Error Handling
+
+  def default_error_handling(data, status_code)
     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
+      if params[:include] || (default_options && default_options[:include])
+        includes = include_hash(nil, params[:include] ? sorted_include_array(params[:include]) : default_options[:include])
+        json = inject_includes(data, includes)
       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
+      render json: filter_json_response(json), status: status_code
     else
       render json: { error: 'Bad Request' }, status: 400
     end
@@ -182,56 +214,64 @@ class GlobalController < ApplicationController
 
   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)
+  def filter_json_response(json)
+    if json.is_a?(Array)
+      json.map { |obj| black_list_include_keys({}, obj) }
+    elsif json[:data] && json[:count]
+      response = json
+      response[:data] = json[:data].map { |obj| black_list_include_keys({}, obj) }
+      response
+    else
+      black_list_include_keys({}, json)
     end
+  end
 
-    array
+  def association_lookup(associations)
+    associations.each_with_object({}) do |e, acc|
+      keyword = e.options && e.options[:as] ?
+        e.options[:as] : e.options && e.options[:source] ?
+        e.options[:source] : false
+      acc[e.klass.name.to_sym] = (keyword.to_s + '_id').to_sym if keyword
+      acc
+    end
   end
 
-  def unique_attributes hash
-    if hash[:key]
-      hash[:key] = append_copy_stamp(hash[:key].to_s)
+  def inject_includes(data, 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
+    json
+  end
+
+  def unique_attributes(hash)
+    hash[:key] = append_copy_stamp(hash[:key].to_s) if hash[:key]
     hash
   end
 
-  def append_copy_stamp str
+  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)
+    offset = limit.to_i * (params[:offset] ? params[:offset].to_i : 0)
     { limit: limit, offset: offset }
   end
 
-  def pagination_data_types(model_hash, options_hash)
+  def pagination_data_types
     data = []
 
-    options_hash ||= {}
+    order = params[:order] || default_options[:order] || nil
+    where = convert_where_hash(params[:where]) || default_options[:where] || nil
+    like = convert_like_string(params[:like]) || default_options[:like] || nil
+    includes = convert_include_array(params[:include]) || default_options[:include] || nil
 
-    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 = 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
@@ -240,43 +280,37 @@ class GlobalController < ApplicationController
     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
+  def pagination_count_type
+    where = default_options[:where] || convert_where_hash(params[:where]) || nil
+    like = convert_like_string(params[:like]) || default_options[:like] || nil
+
+    data = model
+    data = model.where(where) if where
+    data = model.where(*like) if like
+
+    data.count
   end
 
-  def show_data_types(model_hash, options_hash)
+  def show_data_types
     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
+    where = convert_where_hash(params[:where]) || default_options[:where] || nil
+    includes = convert_include_array(params[:include]) || default_options[: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
+    if id.nil?
+      {}
+    elsif  includes && where
+      model.where(where).includes(*includes).first
+    elsif  includes
+      model.includes(*includes).find(id)
+    elsif  where
+      model.where(where).first
+    else
+      model.find(id)
+    end
   end
 
   def convert_like_string(str)
@@ -305,7 +339,7 @@ class GlobalController < ApplicationController
     if str.nil?
       nil
     else
-      str.split(',').each_with_object ({}) do |item, acc|
+      str.split(',').each_with_object({}) do |item, acc|
         key, val = item.split(':')
         acc[key] = dynamic_types(val)
       end
@@ -381,23 +415,13 @@ class GlobalController < ApplicationController
     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)
+      elsif e.is_a?(Array) && e.all? { |item| item.is_a? Hash }
         acc[k] = e.map do |element|
           black_list_include_keys({}, element)
         end

data/lib/constants/cli_constants.rb

@@ -27,7 +27,7 @@ List of commands:
             "This command has no parameters but has optional commands. Optional flag options are:
 --skip=<options-separated-by-a-comma-for-multiple-options>
     Skip Options:
-#{opts.join("\\n")}
+#{opts.join("\n")}
             "
         end
 
@@ -37,6 +37,7 @@ List of commands:
             
 Use the parameters in 'rails generate model' to generate your CRUD operators.
 Optional flag options are:
+--no-model => Do not generate a model in this command
 --skip=<options-separated-by-a-comma-for-multiple-options>
     Skip Options:
 #{opts.join("\n")}

data/lib/constants/options.rb

@@ -2,7 +2,7 @@ class CLIOptions
     class <<self
 
         def gem_version
-            "0.0.9"
+            "0.0.17"
         end
 
         def ascii_art

data/lib/rails_on_rails.rb

@@ -76,6 +76,7 @@ class Commander < CLIOptions
                 puts "Generating model and controller for #{args[2]}..."
                 all_action_methods = [:generate_test_seeder, :generate_test_rspec]
                 skip_options = options[:skip]
+                no_model = !options[:"no-model"].nil?
                 skipping = {}
                 if skip_options
                     skipping = skip_options.split(',').flat_map { |e| skip_model_controller_options[e.to_sym] }.select { |e| e.nil? == false }.each_with_object({}) do |e, acc|
@@ -85,7 +86,7 @@ class Commander < CLIOptions
                 end
                 all_action_methods = all_action_methods.reject { |e| skipping[e].nil? == false }
                 path = __dir__ + '/autogenerators/handlers/controller.rb'
-                system("ruby #{path} #{arguments.join(' ')}")
+                system("ruby #{path} #{no_model} #{arguments.join(' ')}")
                 all_action_methods.each { |e| method(e).call(*args) }
                 puts "Finished generating model and controller for #{args[2]}"
             end

data/lib/utils/rails_methods.rb

@@ -6,4 +6,8 @@ class String
         tr("-", "_").
         downcase
     end
+end
+
+def true?(obj)
+    obj.to_s == "true"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_on_rails
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.17
 platform: ruby
 authors:
 - Aidan Miles