katapult 0.1.0

data/lib/katapult/element.rb

@@ -0,0 +1,72 @@
+# The base class for all katapult elements to inherit from.
+
+# Every katapult element has a name which is a String. All options passed will
+# be mapped to attributes. Afterwards, the optional block will be yielded with
+# self.
+
+module Katapult
+  class Element
+
+    UnknownOptionError = Class.new(StandardError)
+
+    attr_accessor :name, :options
+    attr_reader :application_model
+
+    # Improve semantics in element classes
+    class << self
+      alias_method :options, :attr_accessor
+    end
+
+
+    def initialize(name, options = {})
+      self.name = name.to_s
+      self.options = options
+
+      set_attributes(options)
+
+      yield(self) if block_given?
+    end
+
+    def set_application_model(app_model)
+      @application_model = app_model
+    end
+
+    def name(kind = nil)
+      human_name = @name.downcase
+      machine_name = @name.underscore
+
+      case kind.to_s
+      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_plural' then human_name.pluralize
+      when 'human'        then human_name
+      when 'class'        then machine_name.classify
+      when 'classes'      then machine_name.classify.pluralize
+      else
+        @name
+      end
+    end
+
+    private
+
+    # Map options to attributes.
+    # Example: set_attributes(foo: 123) sets the :foo attribute to 123 (via
+    # #foo=) and raises UnknownOptionError if the attribute does not exist.
+    def set_attributes(options)
+      options.each_pair do |option, value|
+        setter = "#{option}="
+
+        if respond_to? setter
+          send(setter, value)
+        else
+          raise UnknownOptionError, "#{self.class.name} does not support option #{option.inspect}."
+        end
+      end
+    end
+
+  end
+end

data/lib/katapult/generator.rb

@@ -0,0 +1,28 @@
+# The katapult generator base class, slightly adapted from Rails generators.
+
+require 'rails/generators'
+
+module Katapult
+  class Generator < Rails::Generators::NamedBase
+
+    attr_accessor :element
+
+    def initialize(element)
+      self.element = element
+
+      super([element.name], {}, {}) # args, opts, config
+    end
+
+    private
+
+    def app_name
+      File.basename(Dir.pwd)
+    end
+
+    def render_partial(template_path, given_binding = nil)
+      path = File.join(self.class.source_root, template_path)
+      ERB.new(::File.binread(path), nil, '%').result(given_binding || binding)
+    end
+
+  end
+end

data/lib/katapult/model.rb

@@ -0,0 +1,33 @@
+# Models a Rails model.
+
+require 'katapult/element'
+require 'katapult/attribute'
+require 'generators/katapult/model/model_generator'
+
+module Katapult
+  class Model < Element
+
+    UnknownAttributeError = Class.new(StandardError)
+
+    attr_accessor :attrs
+
+    def initialize(*args)
+      self.attrs = []
+
+      super
+    end
+
+    def attr(attr_name, options = {})
+      attrs << Attribute.new(attr_name, options)
+    end
+
+    def label_attr
+      attrs.first
+    end
+
+    def render
+      Generators::ModelGenerator.new(self).invoke_all
+    end
+
+  end
+end

data/lib/katapult/navigation.rb

@@ -0,0 +1,22 @@
+# Models a navigation.
+
+require 'katapult/element'
+require 'generators/katapult/navigation/navigation_generator'
+
+module Katapult
+  class Navigation < Element
+
+    def wuis
+      application_model.wuis
+    end
+
+    def section_name(wui)
+      wui.model_name(:symbols)
+    end
+
+    def render
+      Generators::NavigationGenerator.new(self).invoke_all
+    end
+
+  end
+end

data/lib/katapult/parser.rb

@@ -0,0 +1,39 @@
+# This class reads an application model file and turns it into an
+# ApplicationModel instance.
+
+require_relative 'application_model'
+require 'katapult/model'
+require 'katapult/wui'
+require 'katapult/navigation'
+
+module Katapult
+  class Parser
+
+    def initialize
+      self.application_model = Katapult::ApplicationModel.new
+    end
+
+    def parse(path_to_app_model_file)
+      instance_eval File.read(path_to_app_model_file), path_to_app_model_file
+
+      application_model
+    end
+
+    def model(name, options = {}, &block)
+      application_model.add_model Model.new(name, options, &block)
+    end
+
+    def wui(name, options = {}, &block)
+      application_model.add_wui WUI.new(name, options, &block)
+    end
+
+    def navigation(name)
+      application_model.set_navigation Navigation.new(name)
+    end
+
+    private
+
+    attr_accessor :application_model
+
+  end
+end

data/lib/katapult/util.rb

@@ -0,0 +1,16 @@
+# Utility methods.
+
+# The Katapult::Util module is used inside the `katapult` script. It should not
+# require any gems in order to prevent version conflicts.
+
+module Katapult
+  module Util
+    extend self
+
+    def git_commit(message)
+      message.gsub! /'/, "" # remove single quotes
+      system "git add --all; git commit -m '#{ message }' --author='katapult <katapult@makandra.com>'"
+    end
+
+  end
+end

data/lib/katapult/version.rb

@@ -0,0 +1,3 @@
+module Katapult
+  VERSION = '0.1.0'
+end

data/lib/katapult/wui.rb

@@ -0,0 +1,77 @@
+# Models a controller, including routes and views. Little more than a container
+# class for the Attribute element.
+
+require 'katapult/element'
+require 'katapult/action'
+require 'generators/katapult/w_u_i/w_u_i_generator'
+
+module Katapult
+  class WUI < Element
+
+    options :model
+    attr_accessor :actions
+
+    RAILS_ACTIONS = %w[ index show new create edit update destroy ]
+    UnknownActionError = Class.new(StandardError)
+    UnknownModelError = Class.new(StandardError)
+
+    def initialize(*args)
+      self.actions = []
+
+      super
+    end
+
+    # DSL
+    def action(name, options = {})
+      actions << Action.new(:new, options) if name.to_s == 'create'
+      actions << Action.new(:edit, options) if name.to_s == 'update'
+
+      actions << Action.new(name, options)
+    end
+
+    # DSL
+    def crud
+      %i(index show create update destroy).each &method(:action)
+    end
+
+    def model
+      model_name = @model || self.name
+      application_model.get_model(model_name) or raise UnknownModelError,
+        "Could not find a model named #{model_name}"
+    end
+
+    def custom_actions
+      actions.reject { |a| RAILS_ACTIONS.include? a.name }
+    end
+
+    def find_action(action_name)
+      actions.find { |a| a.name == action_name.to_s }
+    end
+
+    def path(action, object_name = nil)
+      unless action.is_a?(Action)
+        not_found_message = "Unknown action '#{action}'"
+        action = find_action(action) or raise UnknownActionError, not_found_message
+      end
+
+      member_path = "#{model.name(:variable)}_path"
+      collection_path = "#{model.name(:variables)}_path"
+
+      path = ''
+      path << action.name << '_' unless %w[index show destroy].include?(action.name)
+      path << (action.member? ? member_path : collection_path)
+      path << "(#{object_name})" if object_name
+
+      path
+    end
+
+    def model_name(kind = nil)
+      model.name(kind)
+    end
+
+    def render
+      Generators::WUIGenerator.new(self).invoke_all
+    end
+
+  end
+end

data/script/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+# This file imitates the Rails console to ease debugging the gem.
+# Run `script/console` from the gem root to start an IRB with the gem loaded.
+
+# Remember to require classes before using them,
+# i.e. run `require 'katapult/wui'` before `Katapult::WUI.new :example_name`.
+
+irb_options = [
+  '-Ilib',      # add lib/ to load_path
+  '-d',         # set $DEBUG = true
+  '-rkatapult', # require katapult
+  '-f'          # don't read ~/.irbrc
+]
+
+exec 'irb', *irb_options

data/spec/action_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'katapult/action'
+
+describe Katapult::Action do
+
+  subject { described_class.new 'action' }
+
+  describe '#post?' do
+    it 'returns true when its method is :post' do
+      subject.method = :post
+      expect(subject.post?).to be true
+    end
+
+    it 'returns false when its method is :get' do
+      subject.method = :get
+      expect(subject.post?).to be false
+    end
+  end
+
+  describe '#member?' do
+    it 'returns true when its scope is :member' do
+      subject.scope = :member
+      expect(subject.member?).to be true
+    end
+
+    it 'returns false when its scope is :collection' do
+      subject.scope = :collection
+      expect(subject.member?).to be false
+    end
+
+    it 'returns false when it is an index action' do
+      subject = described_class.new :index
+      expect(subject.member?).to be false
+    end
+  end
+
+  describe '#collection?' do
+    it 'returns true when it is an index action' do
+      subject = described_class.new :index
+      expect(subject.collection?).to be true
+    end
+  end
+
+end

data/spec/attribute_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'katapult/attribute'
+
+describe Katapult::Attribute do
+
+  it 'is of type :string by default' do
+    expect(described_class.new('name').type).to eql(:string)
+    expect(described_class.new('address').type).to eql(:string)
+  end
+
+  it 'requires a default for :flag attributes' do
+    expect do
+      described_class.new('attr', type: :flag)
+    end.to raise_error(Katapult::Attribute::MissingOptionError,
+      "The :flag attribute 'attr' requires a default (true or false).")
+  end
+
+  describe '#flag?' do
+    it 'returns whether it is of type :flag' do
+      expect(described_class.new('attr', type: :flag, default: false).flag?).to be true
+      expect(described_class.new('attr', type: :string).flag?).to be false
+    end
+  end
+
+  describe 'available types' do
+    it 'raises an error if the specified type is not supported' do
+      expect do
+        described_class.new('attr', type: :undefined)
+      end.to raise_error(Katapult::Attribute::UnknownTypeError,
+        "Attribute type :undefined is not supported. Use one of #{Katapult::Attribute::TYPES.inspect}."
+      )
+    end
+  end
+
+  describe 'email attributes' do
+    it 'recognizes email attributes' do
+      expect(described_class.new('email').type).to eql(:email)
+      expect(described_class.new('customer_email').type).to eql(:email)
+      expect(described_class.new('name').type).to_not eql(:email)
+    end
+
+    it 'does not overwrite a given type' do
+      expect(described_class.new('email', type: :url).type).to eql(:url)
+      expect(described_class.new('email_updated_at', type: :datetime).type).to eql(:datetime)
+    end
+  end
+
+end

data/spec/model_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'katapult/model'
+require 'katapult/attribute'
+
+describe Katapult::Model do
+
+  subject { described_class.new('model') }
+
+  describe '#label_attr' do
+    it 'returns the model’s first attribute' do
+      subject.attr('first_attr')
+      subject.attr('second_attr')
+
+      expect(subject.label_attr.name).to eql('first_attr')
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'pry'
+
+# Require some Rails for the specs to pass
+require 'active_support/core_ext/string/inflections'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end