katapult 0.3.0 → 0.4.0

data/lib/generators/katapult/model/templates/model.rb

@@ -1,21 +1,31 @@
-class <%= class_name %> < ActiveRecord::Base
+class <%= class_name %> < ApplicationRecord
+
 <%- flag_attrs.each do |attr| -%>
   include DoesFlag[<%= attr.name(:symbol) %>, default: <%= attr.default %>]
 <%- end -%>
+<% has_manys.each do |model| -%>
+  has_many <%= model.name(:symbols) %>
+<% end -%>
+<% belongs_tos.each do |model| -%>
+  belongs_to <%= model.name(:symbol) %>, optional: true
+<% end -%>
 <%- if defaults.any? -%>
+
   has_defaults(<%= defaults %>)
 <%- end -%>
 <%- model.attrs.select(&:assignable_values).each do |attr|  -%>
-  assignable_values_for :<%= attr.name %>, <%= attr.options.slice(:allow_blank, :default) %> do
+
+  assignable_values_for :<%= attr.name(:variable).sub /_id$/, '' %>, <%= attr.options.slice(:allow_blank, :default) %> do
     <%= attr.assignable_values %>
   end
 <%- end -%>
 
   def to_s
-<% if model.label_attr -%>
+<% if model.label_attr? -%>
     <%= model.label_attr.name %>.to_s
 <% else -%>
     "<%= model.name %>##{id}"
 <% end -%>
   end
+
 end

data/lib/generators/katapult/model_specs/model_specs_generator.rb

@@ -19,7 +19,7 @@ module Katapult
       no_tasks do
         def specable_attrs
           model.attrs.select do |attr|
-            attr.assignable_values.present? or attr.default != nil
+            attr.assignable_values_as_list? or !attr.default.nil?
           end
         end
 

data/lib/generators/katapult/model_specs/templates/model_spec.rb

@@ -1,7 +1,7 @@
 describe <%= model.name :class %> do
 
   describe '#to_s' do
-  <%- if model.label_attr -%>
+  <%- if model.label_attr? -%>
     it 'returns the #<%= model.label_attr.name %> attribute' do
       subject.<%= model.label_attr.name %> = <%= model.label_attr.test_value.inspect %>
       expect(subject.to_s).to eq(<%= model.label_attr.test_value.to_s.inspect %>)

data/lib/generators/katapult/transform/transform_generator.rb

@@ -1,12 +1,9 @@
 # Generate files and directories from an application model file. Afterwards do
 # any setup left necessary (e.g. updating the database).
 
-# The application model transformation is split into two parts:
-# 1) parse the model into an object-based representation
-# 2) render the parsed model into code
-
-require 'katapult/parser'
-require 'katapult/generator_goodies'
+# A normal #require would load the application model from the generated app
+require_relative '../../../katapult/application_model'
+require 'katapult/support/generator_goodies'
 
 module Katapult
   class TransformGenerator < Rails::Generators::Base
@@ -20,7 +17,7 @@ module Katapult
     def transform_application_model
       say_status :parse, path
       application_model = File.read(path)
-      @app_model = Katapult::Parser.new.parse(application_model, path)
+      @app_model = Katapult::ApplicationModel.parse(application_model, path)
 
       say_status :render, "into #{app_name}"
       @app_model.render

data/lib/generators/katapult/views/templates/_form.html.haml

@@ -4,36 +4,39 @@
 <% web_ui.model.editable_attrs.each do |attribute| -%>
   .form-group
     = form.label <%= attribute.name(:symbol) %>
-  <%- if attribute.assignable_values -%>
+<% if attribute.type == :foreign_key -%>
+    = form.collection_select <%= attribute.name(:symbol) %>, form.object.assignable_<%= attribute.name(:variables).sub(/_ids$/, 's') %>,
+      :id, <%= attribute.associated_model.label_attr.name(:symbol) %>, { include_blank: true }, class: 'form-control'
+<% elsif attribute.assignable_values -%>
     = form.select <%= attribute.name(:symbol) %>, form.object.assignable_<%= attribute.name(:variables) %>
-  <%- else -%>
-    <%- case attribute.type -%>
-    <%- when :string -%>
+<% else -%>
+  <%- case attribute.type -%>
+  <%- when :string -%>
     = form.text_field <%= attribute.name(:symbol) %>, class: 'form-control'
-    <%- when :email -%>
+  <%- when :email -%>
     = form.email_field <%= attribute.name(:symbol) %>, class: 'form-control'
-    <%- when :password -%>
+  <%- when :password -%>
     = form.password_field <%= attribute.name(:symbol) %>, class: 'form-control',
       autocomplete: 'new-password'
-    <%- when :url -%>
+  <%- when :url -%>
     = form.url_field <%= attribute.name(:symbol) %>, class: 'form-control'
-    <%- when :integer -%>
+  <%- when :integer -%>
     = form.number_field <%= attribute.name(:symbol) %>, class: 'form-control'
-    <%- when :money -%>
+  <%- when :money -%>
     .input-group
       = form.number_field <%= attribute.name(:symbol) %>, class: 'form-control'
       .input-group-addon
         €
-    <%- when :text -%>
+  <%- when :text -%>
     = form.text_area <%= attribute.name(:symbol) %>, rows: 5, class: 'form-control'
-    <%- when :flag -%>
+  <%- when :flag -%>
     .checkbox
       = form.label <%= attribute.name(:symbol) %> do
         = form.check_box <%= attribute.name(:symbol) %>
-    <%- when :datetime -%>
+  <%- when :datetime -%>
     = form.date_field <%= attribute.name(:symbol) %>, class: 'form-control'
-    <%- end -%>
   <%- end -%>
+<% end -%>
 <% end -%>
 
   .action-bar

data/lib/generators/katapult/views/templates/show.html.haml

@@ -35,5 +35,7 @@
     = <%= model_attribute %> ? 'Yes' : 'No'
   <%- when :datetime -%>
     = l(<%= model_attribute %>.to_date) if <%= model_attribute %>
+  <%- when :foreign_key -%>
+    = <%= model_attribute.sub /_id$/, '' %>
   <%- end -%>
 <%- end -%>

data/lib/katapult/application_model.rb

@@ -1,52 +1,101 @@
-# Internal representation of an application model file.
+# Root of the internal representation of an application model file
+
+require 'katapult/elements/model'
+require 'katapult/elements/web_ui'
+require 'katapult/elements/navigation'
+require 'katapult/elements/authentication'
+require 'katapult/elements/association'
 
 module Katapult
   class ApplicationModel
 
-    attr_reader :models, :web_uis, :navigation, :authentication
+    NotFound = Class.new(StandardError)
+
+    attr_reader :models, :web_uis, :navigation, :authentication, :associations
+
+    def self.parse(application_model_string, path_to_model = '')
+      new.tap do |model|
+        model.instance_eval application_model_string, path_to_model
+      end
+    end
 
     def initialize
       @models = []
+      @associations = []
       @web_uis = []
     end
 
-    def add_model(model)
-      model.set_application_model(self)
-      @models << model
+    # DSL
+    def model(name, &block)
+      models << Model.new(name, application_model: self, &block)
+    end
+
+    # DSL
+    def web_ui(name, options = {}, &block)
+      options[:application_model] = self
+      web_uis << WebUI.new(name, options, &block)
+    end
+
+    # DSL
+    def navigation(name = :main)
+      @navigation = Navigation.new(name, application_model: self)
+    end
+
+    # DSL
+    def authenticate(user_model_name, system_email:)
+      @authentication = Authentication.new(user_model_name,
+        system_email: system_email, application_model: self)
     end
 
-    def get_model(name)
-      models.find { |m| m.name == name }
+    # DSL
+    def crud(name, &block)
+      model name, &block
+      web_ui name, &:crud
     end
 
-    def add_web_ui(web_ui)
-      web_ui.set_application_model(self)
-      @web_uis << web_ui
+
+    def association(name, options = {})
+      options[:application_model] = self
+      associations << Association.new(name, options)
+    end
+
+    def get_model!(name)
+      models.find { |m| m.name == name } or raise NotFound,
+        "Could not find a model named #{ name }"
     end
 
     def get_web_ui(name)
       web_uis.find { |w| w.name == name }
     end
 
-    def set_navigation(navigation)
-      navigation.set_application_model(self)
-      @navigation = navigation
+    # Returns all models that `model_name` belongs_to
+    def get_belongs_tos_for(model_name)
+      associations.select { |a| a.name == model_name }.map(&:belongs_to_model)
     end
 
-    def set_authentication(auth)
-      auth.set_application_model(self)
-      auth.ensure_user_model_attributes_present
-      @authentication = auth
+    # Returns all models that `model_name` has_many of
+    def get_has_manys_for(model_name)
+      associations.select { |a| a.belongs_to == model_name }.map(&:model)
     end
 
-    # ---
-
     def render
+      prepare_render
+
       models.each &:render
       web_uis.each &:render
       navigation.render if navigation
       authentication.render if authentication
     end
 
+    private
+
+    def prepare_render
+      authentication &.ensure_user_model_attributes_present
+      models.each do |model|
+        belongs_tos = get_belongs_tos_for(model.name)
+        model.add_foreign_key_attrs(belongs_tos)
+      end
+    end
+
   end
 end

data/lib/katapult/element.rb

@@ -10,10 +10,9 @@ module Katapult
     UnknownOptionError = Class.new(StandardError)
     UnknownFormattingError = Class.new(StandardError)
 
-    attr_accessor :name, :options
-    attr_reader :application_model
+    attr_accessor :name, :options, :application_model
 
-    # Improve semantics in element classes
+    # Use #options for DSL/API, attr_accessor for internal attributes
     class << self
       alias_method :options, :attr_accessor
     end
@@ -28,26 +27,22 @@ module Katapult
       yield(self) if block_given?
     end
 
-    def set_application_model(app_model)
-      @application_model = app_model
-    end
-
     def name(kind = nil)
       machine_name = @name.underscore
       human_name = machine_name.humanize.downcase
 
       case kind.to_s
-      when ''          then @name
-      when 'symbol'    then ":#{machine_name}"
-      when 'symbols'   then ":#{machine_name.pluralize}"
-      when 'variable'  then machine_name
-      when 'variables' then machine_name.pluralize
-      when 'ivar'      then "@#{machine_name}"
-      when 'ivars'     then "@#{machine_name.pluralize}"
-      when 'human'     then human_name
-      when 'humans'    then human_name.pluralize
-      when 'class'     then machine_name.classify
-      when 'classes'   then machine_name.classify.pluralize
+      when ''          then @name                           ## Example
+      when 'symbol'    then ":#{machine_name}"              # :user_task
+      when 'symbols'   then ":#{machine_name.pluralize}"    # :user_tasks
+      when 'variable'  then machine_name                    # user_task
+      when 'variables' then machine_name.pluralize          # user_tasks
+      when 'ivar'      then "@#{machine_name}"              # @user_task
+      when 'ivars'     then "@#{machine_name.pluralize}"    # @user_tasks
+      when 'human'     then human_name                      # user task
+      when 'humans'    then human_name.pluralize            # user tasks
+      when 'class'     then machine_name.classify           # UserTask
+      when 'classes'   then machine_name.classify.pluralize # UserTasks
       else raise UnknownFormattingError, "Unknown name formatting: #{ kind.inspect }"
       end
     end

data/lib/katapult/elements/association.rb

@@ -0,0 +1,35 @@
+# Models an association between models
+
+require 'katapult/element'
+
+module Katapult
+  class Association < Element
+
+    IncompleteAssociationError = Class.new(StandardError)
+
+    options :belongs_to
+
+    def initialize(*args)
+      super
+      validate!
+
+      self.belongs_to = belongs_to.to_s # Normalize
+    end
+
+    def model
+      application_model.get_model! name
+    end
+
+    def belongs_to_model
+      application_model.get_model! belongs_to
+    end
+
+    private
+
+    def validate!
+      belongs_to.present? or raise IncompleteAssociationError,
+        'Missing :belongs_to option'
+    end
+
+  end
+end

data/lib/katapult/{attribute.rb → elements/attribute.rb}

@@ -9,10 +9,12 @@ module Katapult
   class Attribute < Element
 
     options :type, :default, :assignable_values, :allow_blank, :skip_db
+    attr_accessor :model, :associated_model
 
     UnknownTypeError = Class.new(StandardError)
     MissingOptionError = Class.new(StandardError)
-    TYPES = %i(string email password url integer money text flag datetime json plain_json)
+    TYPES = %i[string email password url integer money text flag datetime json
+      plain_json foreign_key]
 
     def initialize(*args)
       super
@@ -21,13 +23,13 @@ module Katapult
       self.type ||= :password if name.to_s =~ /password/
       self.type ||= :string
 
-      validate
+      validate!
     end
 
     delegate :flag?, to: :type_inquiry
 
     def has_defaults?
-      default and not [flag?, assignable_values].any?
+      !default.nil? and not [flag?, assignable_values].any?
     end
 
     def for_migration
@@ -37,13 +39,16 @@ module Katapult
       when :money then 'decimal{10,2}' # {precision,scale} = total digits, decimal places
       when :json then 'jsonb' # Indexable JSON
       when :plain_json then 'json' # Only use this if you need to
+      when :foreign_key then 'integer'
       else type end
 
       "#{name}:#{db_type}"
     end
 
     def test_value
-      if assignable_values
+      if type == :foreign_key
+        associated_model.label_attr.test_value
+      elsif assignable_values
         assignable_values.first
 
       else
@@ -62,13 +67,17 @@ module Katapult
       end
     end
 
+    def assignable_values_as_list?
+      assignable_values.try(:to_a).present?
+    end
+
     private
 
     def type_inquiry
       @type.to_s.inquiry
     end
 
-    def validate
+    def validate!
       TYPES.include?(type) or raise UnknownTypeError,
         "Attribute type :#{type} is not supported. Use one of #{TYPES.inspect}."
 

data/lib/katapult/{authentication.rb → elements/authentication.rb}

@@ -3,14 +3,11 @@ require 'generators/katapult/clearance/clearance_generator'
 module Katapult
   class Authentication < Element
 
-    MissingUserModel = Class.new(StandardError)
-
-    # attr name: The user model name
+    # @attr name: The user model name
     attr_accessor :system_email
 
     def ensure_user_model_attributes_present
-      user_model = application_model.get_model(name) or raise MissingUserModel,
-        "Could not find a model named #{ name }"
+      user_model = application_model.get_model!(name)
       user_attrs = user_model.attrs.map(&:name)
 
       user_model.attr(:email) unless user_attrs.include?('email')

data/lib/katapult/elements/model.rb

@@ -0,0 +1,76 @@
+# Models a Rails model
+
+require 'katapult/element'
+require 'katapult/elements/attribute'
+require 'generators/katapult/model/model_generator'
+
+module Katapult
+  class Model < Element
+
+    UnknownAttributeError = Class.new(StandardError)
+    MissingLabelAttributeError = Class.new(StandardError)
+
+    attr_accessor :attrs, :belongs_tos, :has_manys
+
+    def initialize(*args)
+      self.attrs = []
+      self._belongs_tos = []
+      self.belongs_tos = []
+      self.has_manys = []
+
+      super
+    end
+
+    # DSL
+    def attr(attr_name, options = {})
+      options[:model] = self
+      attrs << Attribute.new(attr_name, options)
+    end
+
+    # DSL
+    def belongs_to(model_name)
+      application_model.association name, belongs_to: model_name
+    end
+
+
+    def label_attr
+      renderable_attrs.first.presence or raise MissingLabelAttributeError
+    end
+
+    def label_attr?
+      label_attr.present?
+    rescue MissingLabelAttributeError
+      false
+    end
+
+    def db_fields
+      attrs.reject(&:skip_db)
+    end
+
+    def renderable_attrs
+      attrs.reject { |a| %w[plain_json json password].include? a.type.to_s }
+    end
+
+    def editable_attrs
+      attrs.reject { |a| %w[plain_json json].include? a.type.to_s }
+    end
+
+    def add_foreign_key_attrs(belongs_tos)
+      belongs_tos.each do |other_model|
+        attr "#{ other_model.name :variable }_id", type: :foreign_key,
+          assignable_values: "#{ other_model.name(:class) }.all.to_a",
+          allow_blank: true,
+          associated_model: other_model
+      end
+    end
+
+    def render
+      Generators::ModelGenerator.new(self).invoke_all
+    end
+
+    private
+
+    attr_accessor :_belongs_tos
+
+  end
+end

data/lib/katapult/{web_ui.rb → elements/web_ui.rb}

@@ -2,7 +2,7 @@
 # class for the Attribute element.
 
 require 'katapult/element'
-require 'katapult/action'
+require 'katapult/elements/action'
 require 'generators/katapult/web_ui/web_ui_generator'
 
 module Katapult
@@ -14,7 +14,6 @@ module Katapult
     RAILS_ACTIONS = %w[ index show new create edit update destroy ]
     UnknownActionError = Class.new(StandardError)
     UnknownModelError = Class.new(StandardError)
-    MissingLabelAttrError = Class.new(StandardError)
 
     def initialize(*args)
       self.actions = []
@@ -41,8 +40,7 @@ module Katapult
 
     def model
       model_name = @model || self.name
-      application_model.get_model(model_name) or raise UnknownModelError,
-        "Cannot find a model named #{model_name}"
+      application_model.get_model! model_name
     end
 
     def params
@@ -81,16 +79,8 @@ module Katapult
     end
 
     def render
-      validate!
       Generators::WebUIGenerator.new(self).invoke_all
     end
 
-    private
-
-    def validate!
-      model.label_attr.present? or raise MissingLabelAttrError,
-        'Cannot render a WebUI without a model with a label attribute'
-    end
-
   end
 end

data/lib/katapult/generator.rb

@@ -1,7 +1,7 @@
-# The katapult generator base class, slightly adapted from Rails generators.
+# The base class for katapult element generators
 
 require 'rails/generators'
-require 'katapult/generator_goodies'
+require 'katapult/support/generator_goodies'
 
 module Katapult
   class Generator < Rails::Generators::NamedBase

data/lib/katapult/{binary_util.rb → support/binary_util.rb}

@@ -2,7 +2,8 @@
 
 # This module is used inside the `katapult` binary and thus should not
 # require any gems in order to prevent version conflicts
-require_relative '../katapult/version'
+
+require_relative '../../katapult/version'
 require 'bundler'
 require 'io/console'
 

data/lib/katapult/{generator_goodies.rb → support/generator_goodies.rb}

@@ -7,8 +7,15 @@ module Katapult::GeneratorGoodies
 
   private
 
-  def app_name
-    File.basename(Dir.pwd)
+  def app_name(kind = nil)
+    machine_name = File.basename(Dir.pwd)
+    human_name = machine_name.tr('_', ' ').gsub(/\w+/, &:capitalize)
+
+    case kind.to_s
+      when ''       then machine_name
+      when 'human'  then human_name
+      else raise ArgumentError, "Unknown formatting: #{kind.inspect}"
+    end
   end
 
   # Override Thor method

data/lib/katapult/version.rb

@@ -1,7 +1,7 @@
 module Katapult
   ruby_version_path = File.expand_path('../../.ruby-version', __dir__)
 
-  VERSION = '0.3.0'
+  VERSION = '0.4.0'
   RUBY_VERSION = File.read(ruby_version_path).strip
   RAILS_VERSION = '5.1.4'
 end

data/script/console

@@ -4,11 +4,14 @@
 # Run `script/console` from the gem root to start an IRB with the gem loaded.
 
 # Remember to require classes before using them,
-# i.e. `require 'katapult/model'` before `Katapult::Model.new :example_name`
+# i.e. `require 'katapult/elements/model'` before using `Katapult::Model`
+
+require 'bundler/setup'
 
 irb_options = [
   '-Ilib',      # add lib/ to load_path
-  '-d',         # set $DEBUG = true
+  # '-d',         # set $DEBUG = true
+
   # Requires
   '-rkatapult/version',
   '-rrails',

data/script/update

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 require_relative '../lib/katapult/version'
-require_relative '../lib/katapult/binary_util'
+require_relative '../lib/katapult/support/binary_util'
 
 u = Katapult::BinaryUtil
 version_path = 'lib/katapult/version.rb'

data/spec/action_spec.rb

@@ -1,4 +1,4 @@
-require 'katapult/action'
+require 'katapult/elements/action'
 
 describe Katapult::Action do
 

data/spec/application_model_spec.rb

@@ -0,0 +1,26 @@
+require 'katapult/application_model'
+
+describe Katapult::ApplicationModel do
+
+  describe '#crud' do
+    it 'adds a model plus a web UI with CRUD actions' do
+      model = <<-MODEL
+crud 'user' do |user|
+  user.attr :age
+end
+      MODEL
+
+      subject = described_class.parse(model)
+      expect(subject.models.count).to be 1
+      user = subject.models.first
+      expect(user.name).to eq 'user'
+      expect(user.attrs.count).to be 1
+      expect(user.attrs.first.name).to eq 'age'
+
+      expect(subject.web_uis.count).to be 1
+      web_ui = subject.web_uis.first
+      expect(web_ui.actions.map(&:name)).to match Katapult::WebUI::RAILS_ACTIONS
+    end
+  end
+
+end