jetski 0.4.8 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 718959913722c396f5ada24d19c6997aee009d7a0aca229156a877def8dba9e4
-  data.tar.gz: 8ad9d4179950762af88e4f4df0a02ff4d8510050a5f7417af440b04f758a78dd
+  metadata.gz: 0fba85e1a50746a7e376738a0ec5648ce22edcc7874ea0d9ee9b3be681d7364d
+  data.tar.gz: b3ac634c65fd946fb1dc43c62702b620b46dd17e1369ef0716eedfa6885e373d
 SHA512:
-  metadata.gz: c1c685e092ab8da1cf08805874d24f3e2319982f11c1a17ce14e92f0342b8ef5622a24cdd4db89e325c36e0a8c842e547057468b592d9028fdbff1fff84963bf
-  data.tar.gz: 847df89c32ce237683bd953da15d589236fe7884707e088e09d0512cc7554a3df09b05a493dd537586e11ac7e094ffc1142e443ea5649d5f1311aea329a669a4
+  metadata.gz: 9740af48073b1a0c8c069d834e2da63c7b351b5a84c5c77502348854c1164105a1002282c8036fa2eaa040cbf085b9e8e8a1ffb98c4b16a87208ca33dccd544c
+  data.tar.gz: cc288a4e32d8dff6c78c14baad4fb317049b2329d30a05bb3132ad1e054db0bf7a0924fec502720b7ae80a7e99d047ee2c364f1e1c5327d81244ddbb2734c6e1

data/bin/jetski

@@ -5,7 +5,12 @@ require 'optparse'
 require 'thor'
 require "pry"
 
+require_relative './jetski_cli_helpers/generators/controller.rb'
+require_relative './jetski_cli_helpers/generators/model.rb'
+require_relative './jetski_cli_helpers/destroyers/controller.rb'
+require_relative './jetski_cli_helpers/destroyers/model.rb'
 require_relative './jetski_cli_helpers/shared_methods.rb'
+require_relative './jetski_cli_helpers/base.rb'
 require_relative './jetski_cli_helpers/generate.rb'
 require_relative './jetski_cli_helpers/destroy.rb'
 require_relative './jetski_cli_helpers/database.rb'

data/bin/jetski_cli_helpers/base.rb

@@ -0,0 +1,11 @@
+# Reason for this is to dry up code and includes between classes
+module JetskiCLIHelpers
+  class Base < Thor
+    include Jetski::Helpers::Generic, Thor::Actions, JetskiCLIHelpers::SharedMethods,
+      Jetski::Database::Base, Jetski::Database::Interface
+    
+    def self.source_root
+      File.join(File.dirname(__FILE__), '..', '..', 'templates')
+    end
+  end
+end

data/bin/jetski_cli_helpers/database.rb

@@ -1,16 +1,20 @@
-require 'thor'
 module JetskiCLIHelpers
-  class Database < Thor
-    include Thor::Actions, JetskiCLIHelpers::SharedMethods,
-      Jetski::Database::Base
-    desc "create", "Creates a database for your app"
-    def create
-      say "🌊 Database was created successfully!"
-    end
-
-    desc "create_table NAME COLUMN_NAMES", "Creates a new table in your database"
-    def create_table(name, *fields)
-      db.execute create_table_sql(table_name: name, field_names: fields)
+  class Database < Base
+    desc "migrate", "Create, load, and patch DB from models"
+    def migrate
+      Jetski::Autoloader.call
+      # Get all models defined in users app
+      Jetski::Model.subclasses.each do |model|
+        table_name = model.pluralized_table_name
+        # Create table if it doesnt exist
+        create_table(table_name) if !table_exists?(table_name)
+        # Get model attributes
+        model.db_attribute_values.each do |obj|
+          name = obj[:name]
+          type = obj[:type]
+          add_column_unless_exists(table_name, name, type)
+        end
+      end
     end
 
     desc "seed", "Seeds the database with records created from seed file"

data/bin/jetski_cli_helpers/destroy.rb

@@ -1,20 +1,21 @@
-require 'thor'
 module JetskiCLIHelpers
-  class Destroy < Thor
-    include Thor::Actions
+  class Destroy < Base
+    include JetskiCLIHelpers::Destroyers::Controller,
+    JetskiCLIHelpers::Destroyers::Model
     desc "controller NAME ACTION_NAMES", "Destroys a controller"
     def controller(name, *actions)
-      controller_file_path = "app/controllers/#{name}_controller.rb"
-      remove_file(controller_file_path)
-      view_folder = "app/views/#{name}"
-      remove_dir(view_folder)
+      destroy_controller(name)
     end
 
     desc "model NAME ACTION_NAMES", "Destroys a model"
     def model(name, *actions)
-      model_file_path = "app/models/#{name}.rb"
-      remove_file(controller_file_path)
-      # TODO: Remove from db.
+      destroy_model(name)
+    end
+
+    desc "resource NAME ACTION_NAMES", "Destroys a resource"
+    def resource(name, *actions)
+      destroy_controller(name)
+      destroy_model(name)
     end
   end
 end

data/bin/jetski_cli_helpers/destroyers/controller.rb

@@ -0,0 +1,13 @@
+module JetskiCLIHelpers
+  module Destroyers
+    module Controller
+      def destroy_controller(name)
+        controller_name = pluralize_string(name)
+        controller_file_path = "app/controllers/#{controller_name}_controller.rb"
+        remove_file(controller_file_path)
+        view_folder = "app/views/#{controller_name}"
+        remove_dir(view_folder)
+      end
+    end
+  end
+end

data/bin/jetski_cli_helpers/destroyers/model.rb

@@ -0,0 +1,13 @@
+module JetskiCLIHelpers
+  module Destroyers
+    module Model
+      def destroy_model(name)
+        model_file_path = "app/models/#{name}.rb"
+        remove_file(model_file_path)
+        table_name = pluralize_string(name)
+        remove_table_sql = "DROP TABLE #{table_name}"
+        db.execute(remove_table_sql)
+      end
+    end
+  end
+end

data/bin/jetski_cli_helpers/generate.rb

@@ -1,52 +1,22 @@
-require 'thor'
 module JetskiCLIHelpers
-  class Generate < Thor
-    include Thor::Actions, JetskiCLIHelpers::SharedMethods, 
-      Jetski::Database::Base
+  class Generate < Base
+    include JetskiCLIHelpers::Generators::Controller,
+      JetskiCLIHelpers::Generators::Model
     desc "controller NAME ACTION_NAMES", "Create a controller with matching actions"
     def controller(name, *actions)
-      controller_file_path = "app/controllers/#{name}_controller.rb"
-      create_file controller_file_path
-      append_to_file controller_file_path, <<~CONTROLLER
-        class #{name.capitalize}Controller < Jetski::BaseController
-
-        end
-      CONTROLLER
-
-      actions.each.with_index do |action_name, idx|
-        action_content = <<~ACTION_CONTENT
-          def #{action_name}
-
-          end
-        ACTION_CONTENT
-        action_nl_seperator = ((idx + 1) != actions.size) ? "\n\n" : ""
-        insert_into_file(controller_file_path, "#{indent_code(action_content, 1)}#{action_nl_seperator}", before: "\nend")
-        
-        if !["create", "create", "update", "destroy"].include?(action_name)
-          path_to_view = "app/views/#{name}/#{action_name}.html.erb"
-
-          empty_directory("app/views/#{name}")
-          create_file(path_to_view)
-          append_to_file path_to_view, <<~EXAMPLEFILE
-            <h1> #{name}##{action_name} </h1>
-            <p> edit the content of this page at app/views/#{path_to_view}/#{action_name}.html.erb </p>
-          EXAMPLEFILE
-            
-          say "🌊 View your new page at http://localhost:8000/#{name}/#{action_name}"
-        end
-      end
+      generate_controller(name, *actions)
     end
 
     desc "model NAME FIELD_NAMES", "Creates a model with matching fields"
     def model(name, *field_names)
-      db.execute create_table_sql(table_name: name, field_names: field_names)
-      model_file_path = "app/models/#{name}.rb"
-      create_file model_file_path
-      append_to_file model_file_path, <<~MODEL
-        class #{name.capitalize} < Jetski::Model
-          
-        end
-      MODEL
+      generate_model(name, *field_names)
+    end
+
+    desc "resource NAME FIELD_NAMES", "Creates a resource with model and controller and crud routes"
+    def resource(name, *field_names)
+      crud_actions = %w(new create show index edit update destroy)
+      generate_model(name, *field_names)
+      generate_controller(name, *crud_actions, field_names: field_names)
     end
   end
 end

data/bin/jetski_cli_helpers/generators/controller.rb

@@ -0,0 +1,40 @@
+module JetskiCLIHelpers
+  module Generators
+    module Controller
+      def generate_controller(name, *actions, **extra_options)
+        field_names = extra_options[:field_names]
+        @name = name
+        @controller_name = pluralize_string(name)
+
+        controller_file_path = "app/controllers/#{@controller_name}_controller.rb"
+        
+        @controller_class_name = @controller_name.split("_").map(&:capitalize).join
+        @model_class_name = @name.capitalize # post -> Post
+        @field_names = field_names
+        @actions = actions
+
+        # Create controller from template
+        template "controllers/controller.rb.erb", controller_file_path
+        
+        actions.each do |action_name|
+          # create views
+          if !["create", "create", "update", "destroy"].include?(action_name)
+            empty_directory("app/views/#{@controller_name}")
+            
+            # For new, show, edit, index actions
+            @path_to_view = "app/views/#{@controller_name}/#{action_name}.html.erb"
+            
+            template_name = if ["new", "show", "edit", "index"].include?(action_name)
+              action_name
+            else
+              "default"
+            end  
+            @action_name = action_name
+            template "controllers/views/#{template_name}.html.erb", @path_to_view
+            say "🌊 View your new page at http://localhost:8000/#{@controller_name}/#{action_name}"
+          end
+        end
+      end
+    end
+  end
+end

data/bin/jetski_cli_helpers/generators/model.rb

@@ -0,0 +1,31 @@
+module JetskiCLIHelpers
+  module Generators
+    module Model
+      def generate_model(name, *field_names)
+        # TODO: Instead of creating table here we should have a db:migrate method
+        # this will automatically build and patch db tables. Add/remove columns 
+        #db.execute create_table_sql(table_name: name, field_names: field_names)
+        @model_name = name
+
+        
+        if field_names
+          @model_attributes = []
+          custom_fields = field_names.filter { |f| f.include?(":") }
+          string_fields = field_names - custom_fields
+          string_fields.each do |field|
+            @model_attributes << ":#{field}"
+          end
+
+          custom_fields.each do |custom_field|
+            field, type = custom_field.split(":")
+            @model_attributes << "#{field}: :#{type}"
+          end
+        end
+          
+        model_file_path = "app/models/#{name}.rb"
+        template "model/template.rb.erb", model_file_path
+      end
+    end
+  end
+end
+

data/lib/jetski/autoloader.rb

@@ -1,6 +1,6 @@
-module Jetski
+class Jetski
   module Autoloader
-    include Jetski::Router::SharedMethods
+    include Jetski::Router::FilePathHelper
     extend self
     # Responsibility is to load all models in app.
     def call
@@ -12,10 +12,6 @@ module Jetski
           .split("/")
           .map(&:capitalize)
           .join("::")
-        # posts/comment
-        # Post/comment
-        model_class = Object.const_get(model_name)
-        model_class.define_attribute_methods
       end
     end
 

data/lib/jetski/base_controller.rb

@@ -1,12 +1,12 @@
 # This is the base controller of the library
-module Jetski
+class Jetski
   class BaseController
     RESERVED_INSTANCE_VARIABLES = [
         :@res, :@performed_render, :@action_name, 
         :@controller_name, :@controller_path, :@cookies
     ]
 
-    include ReactiveForm
+    include Jetski::Frontend::JavascriptHelpers
     extend Jetski::Helpers::RouteHelpers
     attr_accessor :action_name, :controller_name, :controller_path, 
       :params, :cookies
@@ -19,8 +19,6 @@ module Jetski
     end
 
     # Method to render matching view with controller_name/action_name
-    # TODO: Make render available in view as seperate method.
-
     def render(**args)
       @performed_render = true
       request_status = args[:status] || 200

data/lib/jetski/database/base.rb

@@ -1,4 +1,4 @@
-module Jetski
+class Jetski
   module Database
     module Base
       extend self
@@ -7,35 +7,13 @@ module Jetski
         @_db ||= SQLite3::Database.new "test.db"
       end
 
-      def create_table_sql(table_name:, field_names:)
-        pluralized_table_name = if table_name.chars.last == "s"
-          table_name
-        else
-          table_name + "s"
-        end
-
-        _gen_sql = ""
-        _gen_sql += "create table #{pluralized_table_name} (\n"
-        
-        # Default fields on all models
-        _gen_sql += "  created_at datetime,\n"
-        _gen_sql += "  updated_at datetime,\n"
-        _gen_sql += "  id integer,\n"
-
-        field_names.each.with_index do |field_name, idx|
-          field, field_data_type = if field_name.include?(":")
-            field_name.split(":")
-          else
-            [field_name, ""]
-          end
-          data_type = sql_data_type(field_data_type)
-          _gen_sql += "  #{field} #{data_type}"
-          if (idx + 1) < field_names.size
-            _gen_sql += ",\n"
-          else
-            _gen_sql += "\n"
-          end
-        end
+      def create_table_sql(table_name:, field_names: [])
+        table_name = pluralize_string(table_name)
+        default_fields = [["created_at", "datetime"], ["updated_at", "datetime"], ["id", "integer"]]
+        fields = field_names.map { |f| f.split(":") }
+        all_fields = fields + default_fields
+        _gen_sql = "create table #{table_name} (\n"
+        _gen_sql += all_fields.map { |field, data_type| " #{field} #{data_type}" }.join(",\n")
         _gen_sql += ");\n"
         _gen_sql
       end

data/lib/jetski/database/interface.rb

@@ -0,0 +1,31 @@
+# Responsibility is to wrap calls to db and make it more clean and readable.
+
+class Jetski
+  module Database
+    module Interface
+      extend self
+
+      # expects an array of fields with type seperated by colon :
+      def create_table(table_name, *fields)
+        db.execute create_table_sql(table_name: table_name, field_names: fields)
+      end
+
+      def add_column(table_name, field_name, data_type = "string")
+        db.execute("ALTER TABLE #{table_name} ADD #{field_name} #{sql_data_type(data_type)}")
+      end
+
+      def add_column_unless_exists(table_name, field_name, data_type = nil)
+        add_column(table_name, field_name, data_type) if !field_exists?(table_name, field_name)
+      end
+
+      def table_exists?(table_name)
+        db.get_first_value("SELECT name FROM sqlite_master WHERE type='table' AND name=?", table_name)
+      end
+
+      def field_exists?(table_name, field_name)
+        table_info = db.execute("PRAGMA table_info(#{table_name})")
+        table_info.find { |d| d[1] == field_name } != nil
+      end
+    end
+  end
+end

data/lib/jetski/database/sqlite3.rb

@@ -0,0 +1,6 @@
+class Jetski
+  module Database
+    module Sqlite3
+    end
+  end
+end

data/lib/jetski/frontend/javascript_helpers.rb

@@ -0,0 +1,12 @@
+class Jetski
+  module Frontend
+    module JavascriptHelpers
+      def reactive_text_area(path, **opts)
+        css_classes = opts[:class]
+        value = opts[:value]
+        # Text area that auto saves to url.
+        "<textarea reactive-form-path='#{path}' class='#{css_classes}'>#{value}</textarea>"
+      end
+    end
+  end
+end

data/lib/jetski/helpers/delegatable.rb

@@ -1,4 +1,4 @@
-module Jetski
+class Jetski
   module Helpers
     module Delegatable
       # delegate(:method, to: :class)

data/lib/jetski/helpers/generic.rb

@@ -0,0 +1,14 @@
+class Jetski
+  module Helpers
+    module Generic
+      # Helpers for use all over codebase for simple grammatics etc..
+      def pluralize_string(string)
+        if string[-1] == 's'
+          string
+        else
+          string + 's'
+        end
+      end
+    end
+  end
+end

data/lib/jetski/helpers/route_helpers.rb

@@ -1,10 +1,9 @@
 # This is responsible for methods for routing in base_controller like the route class method
 
-module Jetski
+class Jetski
   module Helpers
     module RouteHelpers
       def route(method_name, root: false, path: nil, request_method: nil)
-        # TODO: write code to set route
         @custom_route_opts ||= {}
         @custom_route_opts[method_name] = {
           method_name: method_name,

data/lib/jetski/helpers/view_helpers.rb

@@ -1,4 +1,4 @@
-module Jetski
+class Jetski
   module Helpers
     module ViewHelpers
       # Expecting a relative path.
@@ -21,24 +21,60 @@ module Jetski
       end
 
       # button_to("Click me", class: "cool-btn")
-      def button_to(button_text, **html_opts)
-        "<button #{format_html_options(**html_opts)}>#{button_text}</button>"
+      def button_to(button_text, url = nil, **html_opts)
+        if url
+          _method = html_opts[:method] || 'POST'
+          # Create form with button inside lol
+          _form = "<form action='#{url}' method='#{_method}'>"
+          _form += "<button type='submit' #{format_html_options(**html_opts)}>#{button_text}</button>"
+          _form += "</form>"
+          _form
+        else
+          _button = "<button #{format_html_options(**html_opts)}>#{button_text}</button>"
+        end
       end
 
-      def input_tag(**html_opts)
+      def input_tag(input_name = nil, **html_opts)
+        html_opts[:name] ||= input_name
         "<input #{format_html_options(**html_opts)}>"
       end
 
-      def textarea_tag(**html_opts)
-        "<textarea #{format_html_options(**html_opts.except(:value))}>#{html_opts[:value]}</textarea>"
+      def label_tag(text, **html_opts)
+        "<label #{format_html_options(**html_opts)}>#{text}</label>"
+      end
+
+      def textarea_tag(name = nil, value = nil, **html_opts)
+        html_opts[:name] ||= name
+        value ||= html_opts[:value]
+        "<textarea #{format_html_options(**html_opts.except(:value))}>#{value}</textarea>"
       end
 
       def image_tag(image_path, **html_opts)
-        "<img src='#{image_path}' #{format_html_options(**html_opts)}></img>"
+        abs_url = process_url(image_path)
+        "<img src='#{abs_url}' #{format_html_options(**html_opts)}></img>"
       end
 
       def favicon_tag(url, **html_opts)
-        "<link rel='icon' type='image/x-icon' #{format_html_options(**html_opts)} href='#{url}'>"
+        abs_url = process_url(url)
+        "<link rel='icon' type='image/x-icon' #{format_html_options(**html_opts)} href='#{abs_url}'>"
+      end
+
+      def stylesheet_tag(url, **html_opts)
+        abs_url = process_url(url)
+        "<link rel='stylesheet' #{format_html_options(**html_opts)} href='#{abs_url}'>"
+      end
+
+      def javascript_include_tag(url, **html_opts)
+        abs_url = process_url(url)
+        "<script src='#{abs_url}' #{format_html_options(**html_opts)}></script>"
+      end
+
+      def javascript_tag(**html_opts)
+        "<script #{format_html_options(**html_opts)}>#{yield}</script>"
+      end
+
+      def truncate(text, limit)
+        text[0..limit]
       end
 
       def format_html_options(**html_opts)
@@ -47,6 +83,15 @@ module Jetski
           "#{formatted_key}='#{v}'"
         end.join(" ")
       end
+    private
+      # TODO: could move this to a sharable method.
+      def process_url(url)
+        if url[0] == '/'
+          url
+        else
+          "/#{url}"
+        end
+      end
     end
   end
 end

data/lib/jetski/model/attributes.rb

@@ -0,0 +1,46 @@
+class Jetski
+  class Model
+    module Attributes
+      # class method for user to configure add/remove attributes on model
+      def attributes(*string_attributes, **custom_attributes)
+        @_db_string_attributes = string_attributes
+        @_db_custom_attributes = custom_attributes
+        combined_attributes = string_attributes + custom_attributes.map { |k, _v| k }
+        @_attribute_names ||= []
+        @_attribute_names.concat(combined_attributes)
+        @_attribute_names.concat([:created_at, :updated_at, :id]) # defaults
+        @_attribute_names = @_attribute_names.uniq
+        @_attribute_names.each do |attribute|
+          define_method attribute do
+            @virtual_attributes[attribute]
+          end
+        end
+      end
+
+      def attribute_names
+        @_attribute_names || []
+      end
+
+      def db_attribute_values
+        # Returns the formatted objects with types for each attribute
+        _db_attributes = []
+        
+        @_db_string_attributes.each do |value|
+          _db_attributes << {
+            name: value,
+            type: :string
+          }
+        end
+
+        @_db_custom_attributes.each do |key, value|
+          _db_attributes << {
+            name: key,
+            type: value
+          }
+        end
+
+        _db_attributes
+      end
+    end
+  end
+end

data/lib/jetski/model/crud_helpers.rb

@@ -0,0 +1,76 @@
+class Jetski
+  class Model
+    module CrudHelpers
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      def destroy!
+        # Destroy record: remove from db
+        delete_sql = <<~SQL
+          DELETE from #{self.class.pluralized_table_name} WHERE id=?
+        SQL
+        self.class.db.execute(delete_sql, id)
+        nil
+      end
+
+      module ClassMethods
+        def create(hash_args = nil, **key_args)
+          args = if hash_args && hash_args.is_a?(Hash)
+            hash_args
+          else
+            key_args
+          end
+
+          return puts "#{table_name.capitalize}.create was called with no args" if args.size == 0
+          data_values = args.map { |k,v| v }
+          key_names = args.map { |k, v| k }
+          
+          # Set default values on create
+
+          key_names.append "created_at"
+          data_values.append Time.now.to_s
+
+          current_record_count = (count || 0)
+          record_id = current_record_count + 1
+          key_names.append "id"
+          data_values.append(record_id)
+
+          sql_command = <<~SQL
+            INSERT INTO #{pluralized_table_name} (#{key_names.join(", ")}) 
+            VALUES (#{(1..key_names.size).map { |n| "?" }.join(", ")})
+          SQL
+
+          db.execute(sql_command, data_values)
+
+          record_attributes = {}
+          key_names.each.with_index do |k, i|
+            record_attributes[k.to_sym] = data_values[i]
+          end
+
+          new(**record_attributes)
+        end
+
+        def all
+          columns, *rows = db.execute2( "select * from #{pluralized_table_name}" )
+          _all = []
+          rows.map do |row|
+            _all << format_model_obj(row, columns)
+          end
+          _all
+        end
+
+        def find(id)
+          id_as_integer = id.to_i
+          columns, *rows = db.execute2( "select * from #{pluralized_table_name} WHERE id=?", id_as_integer)
+          format_model_obj(rows.last, columns)
+        end
+      
+
+        def destroy_all! 
+          db.execute("DELETE from #{pluralized_table_name}")
+        end
+      end
+    end
+  end
+end