kangaru 0.1.0

data/lib/kangaru/configurators/configurator.rb

@@ -0,0 +1,22 @@
+module Kangaru
+  module Configurators
+    class Configurator
+      include Concerns::AttributesConcern
+
+      using Patches::Inflections
+
+      def self.key
+        to_s.gsub(/^.*::(?!.*::)/, "")
+            .delete_suffix("Configurator")
+            .to_snakecase
+            .to_sym
+      end
+
+      def serialise
+        self.class.attributes.to_h do |setting|
+          [setting, send(setting)]
+        end.compact
+      end
+    end
+  end
+end

data/lib/kangaru/configurators/database_configurator.rb

@@ -0,0 +1,7 @@
+module Kangaru
+  module Configurators
+    class DatabaseConfigurator < Configurator
+      attr_accessor :adaptor, :path, :migration_path
+    end
+  end
+end

data/lib/kangaru/configurators/external_configurator.rb

@@ -0,0 +1,6 @@
+module Kangaru
+  module Configurators
+    class ExternalConfigurator < OpenConfigurator
+    end
+  end
+end

data/lib/kangaru/configurators/open_configurator.rb

@@ -0,0 +1,33 @@
+# Similar to a standard configurator, except on initialisation, it will set
+# accessors for every attribute specified. This means that the super call will
+# lead to each value being set as if the accessor was defined in the class.
+module Kangaru
+  module Configurators
+    class OpenConfigurator < Configurator
+      using Patches::Symboliser
+
+      def initialize(**)
+        set_accessors!(**)
+
+        super
+      end
+
+      # Import contents of a yaml file
+      def self.from_yaml_file(path)
+        raise "path does not exist" unless File.exist?(path)
+
+        attributes = YAML.load_file(path).symbolise
+
+        new(**attributes)
+      end
+
+      private
+
+      def set_accessors!(**attributes)
+        attributes.each_key do |key|
+          self.class.class_eval { attr_accessor key }
+        end
+      end
+    end
+  end
+end

data/lib/kangaru/configurators/request_configurator.rb

@@ -0,0 +1,7 @@
+module Kangaru
+  module Configurators
+    class RequestConfigurator < Configurator
+      attr_accessor :default_controller
+    end
+  end
+end

data/lib/kangaru/configurators.rb

@@ -0,0 +1,12 @@
+module Kangaru
+  module Configurators
+    # These are not set as accessors by Config instances as they are abstract.
+    BASE_CONFIGURATORS = [Configurator, OpenConfigurator].freeze
+
+    def self.classes
+      constants.map    { |constant| const_get(constant) }
+               .select { |constant| constant.is_a?(Class) }
+               .reject { |constant| BASE_CONFIGURATORS.include?(constant) }
+    end
+  end
+end

data/lib/kangaru/controller.rb

@@ -0,0 +1,53 @@
+module Kangaru
+  class Controller
+    extend Forwardable
+
+    using Patches::Inflections
+
+    SUFFIX = "Controller".freeze
+
+    attr_reader :request
+
+    def initialize(request)
+      @request = request
+    end
+
+    def execute
+      public_send(request.action)
+
+      renderer_for(request.action.to_s).render(binding)
+    end
+
+    # Returns the partial path for the controller based on the class name.
+    # The first module namespace is removed as this is either Kangaru or the
+    # target gem namespace. Used to infer the location of view files.
+    def self.path
+      name&.delete_suffix(SUFFIX)&.gsub(/^.*?::/, "")&.to_snakecase || raise
+    end
+
+    def_delegators :request, :params
+
+    private
+
+    def view_path(file)
+      Kangaru.application.view_path(self.class.path, file)
+    end
+
+    def renderer_for(file)
+      Renderer.new(view_path(file))
+    end
+
+    # The binding passed to the renderer is not scoped to the application
+    # namespace, and as such, all application classes must be prefixed with the
+    # namespace module. This change emulates the binding being created from
+    # within the application namespace by delegating const lookups to said
+    # namespace if the constant is not in scope from the current class.
+    def self.const_missing(const)
+      return super unless Kangaru.application.namespace.const_defined?(const)
+
+      Kangaru.application.namespace.const_get(const)
+    end
+
+    private_class_method :const_missing
+  end
+end

data/lib/kangaru/database.rb

@@ -0,0 +1,54 @@
+module Kangaru
+  class Database
+    extend Forwardable
+
+    include Concerns::AttributesConcern
+
+    PLUGINS = %i[
+      enum
+      timestamps
+    ].freeze
+
+    attr_accessor :adaptor, :path, :migration_path
+
+    attr_reader :handler
+
+    def setup!
+      raise "adaptor can't be blank" if adaptor.nil?
+
+      @handler = case adaptor
+                 when :sqlite then setup_sqlite!
+                 else raise "invalid adaptor '#{adaptor}'"
+                 end
+    end
+
+    def migrate!
+      return unless handler
+      return unless migrations_exist?
+
+      Sequel.extension(:migration)
+
+      Sequel::Migrator.run(handler, migration_path)
+    end
+
+    def_delegators :handler, :tables
+
+    private
+
+    def migrations_exist?
+      return false if migration_path.nil?
+
+      Dir.exist?(migration_path) && !Dir.empty?(migration_path)
+    end
+
+    def setup_sqlite!
+      raise "path can't be blank" if path.nil?
+
+      FileUtils.mkdir_p(File.dirname(path))
+
+      Sequel.sqlite(path).tap do
+        PLUGINS.each { |plugin| Sequel::Model.plugin(plugin) }
+      end
+    end
+  end
+end

data/lib/kangaru/inflectors/class_inflector.rb

@@ -0,0 +1,13 @@
+module Kangaru
+  module Inflectors
+    class ClassInflector < Inflector
+      filter_input_with(/\.[a-z]+$/)
+
+      transform_tokens_with :capitalize
+
+      join_tokens_with ""
+
+      join_groups_with "::"
+    end
+  end
+end

data/lib/kangaru/inflectors/constant_inflector.rb

@@ -0,0 +1,13 @@
+module Kangaru
+  module Inflectors
+    class ConstantInflector < ClassInflector
+      LAST_WORD = /(::)?(?!.*::)(.*)$/
+
+      def inflect
+        super.gsub(LAST_WORD) do |last_word|
+          ScreamingSnakecaseInflector.inflect(last_word)
+        end
+      end
+    end
+  end
+end

data/lib/kangaru/inflectors/constantiser.rb

@@ -0,0 +1,18 @@
+module Kangaru
+  module Inflectors
+    class Constantiser
+      using Patches::Inflections
+
+      def self.constantise(string, root: Object)
+        as_class    = string.to_class_name
+        as_constant = string.to_constant_name
+
+        if root.const_defined?(as_class)
+          root.const_get(as_class)
+        elsif root.const_defined?(as_constant)
+          root.const_get(as_constant)
+        end
+      end
+    end
+  end
+end

data/lib/kangaru/inflectors/human_inflector.rb

@@ -0,0 +1,15 @@
+module Kangaru
+  module Inflectors
+    class HumanInflector < Inflector
+      transform_tokens_with :downcase
+
+      join_tokens_with " "
+
+      join_groups_with " "
+
+      post_process_with do |output|
+        output.strip.capitalize
+      end
+    end
+  end
+end

data/lib/kangaru/inflectors/inflector.rb

@@ -0,0 +1,98 @@
+module Kangaru
+  module Inflectors
+    class Inflector
+      extend InflectorMacros
+
+      DEFAULT_GROUP_JOINER = "/".freeze
+
+      attr_reader :string
+
+      def initialize(string)
+        @string = filter_input(string)
+      end
+
+      def inflect
+        post_process(
+          join_groups(
+            transform_and_join_tokens(tokeniser.split)
+          )
+        )
+      end
+
+      def self.inflect(string)
+        new(string).inflect
+      end
+
+      private
+
+      def tokeniser
+        @tokeniser ||= Tokeniser.new(string)
+      end
+
+      def class_attribute(key)
+        self.class.instance_variable_get(:"@#{key}")
+      end
+
+      def input_filter
+        class_attribute(:input_filter)
+      end
+
+      def token_transformer
+        class_attribute(:token_transformer)
+      end
+
+      def token_joiner
+        class_attribute(:token_joiner)
+      end
+
+      def group_joiner
+        class_attribute(:group_joiner) || DEFAULT_GROUP_JOINER
+      end
+
+      def post_processor
+        class_attribute(:post_processor)
+      end
+
+      def filter_input(input)
+        case input_filter
+        when Regexp then input.gsub(input_filter, "")
+        else input
+        end
+      end
+
+      def transform_and_join_tokens(token_groups)
+        token_groups.map do |tokens|
+          join_tokens(
+            tokens.map { |token| transform_token(token) }
+          )
+        end
+      end
+
+      def transform_token(token)
+        case token_transformer
+        when Proc   then token_transformer.call(token)
+        when Symbol then token.send(token_transformer)
+        else token
+        end
+      end
+
+      def join_tokens(tokens)
+        tokens.join(token_joiner)
+      end
+
+      def join_groups(words)
+        words.join(group_joiner)
+      end
+
+      def post_process(string)
+        return string if post_processor.nil?
+
+        case post_processor
+        when Proc   then post_processor.call(string)
+        when Symbol then string.send(post_processor)
+        else string
+        end
+      end
+    end
+  end
+end

data/lib/kangaru/inflectors/inflector_macros.rb

@@ -0,0 +1,33 @@
+module Kangaru
+  module Inflectors
+    module InflectorMacros
+      def inherited(child_class)
+        instance_variables.each do |rule|
+          value = instance_variable_get(rule)
+
+          child_class.instance_variable_set(rule, value)
+        end
+      end
+
+      def filter_input_with(pattern)
+        @input_filter = pattern
+      end
+
+      def transform_tokens_with(symbol = nil, &block)
+        @token_transformer = symbol || block
+      end
+
+      def join_tokens_with(joiner)
+        @token_joiner = joiner
+      end
+
+      def join_groups_with(joiner)
+        @group_joiner = joiner
+      end
+
+      def post_process_with(symbol = nil, &block)
+        @post_processor = symbol || block
+      end
+    end
+  end
+end

data/lib/kangaru/inflectors/path_inflector.rb

@@ -0,0 +1,21 @@
+module Kangaru
+  module Inflectors
+    class PathInflector < Inflector
+      filter_input_with(/\.[a-z]+$/)
+
+      transform_tokens_with :downcase
+
+      join_tokens_with "_"
+
+      join_groups_with "/"
+
+      def inflect(with_ext: nil)
+        inflection = super()
+
+        return inflection unless with_ext
+
+        "#{inflection}.#{with_ext}"
+      end
+    end
+  end
+end

data/lib/kangaru/inflectors/screaming_snakecase_inflector.rb

@@ -0,0 +1,11 @@
+module Kangaru
+  module Inflectors
+    class ScreamingSnakecaseInflector < SnakecaseInflector
+      join_groups_with "::"
+
+      def inflect
+        super.upcase
+      end
+    end
+  end
+end

data/lib/kangaru/inflectors/snakecase_inflector.rb

@@ -0,0 +1,11 @@
+module Kangaru
+  module Inflectors
+    class SnakecaseInflector < Inflector
+      transform_tokens_with :downcase
+
+      join_tokens_with "_"
+
+      join_groups_with "/"
+    end
+  end
+end

data/lib/kangaru/inflectors/tokeniser.rb

@@ -0,0 +1,20 @@
+module Kangaru
+  module Inflectors
+    class Tokeniser
+      GROUP_DELIMITER = %r{/|::}
+      TOKEN_DELIMITER = /[_-]+|(?=[A-Z][a-z])/
+
+      attr_reader :string
+
+      def initialize(string)
+        @string = string
+      end
+
+      def split
+        string.split(GROUP_DELIMITER).map do |group|
+          group.split(TOKEN_DELIMITER)
+        end
+      end
+    end
+  end
+end

data/lib/kangaru/initialiser.rb

@@ -0,0 +1,12 @@
+module Kangaru
+  module Initialiser
+    def self.extended(namespace)
+      source = caller[0].gsub(/:.*$/, "")
+
+      Kangaru.application = Application.new(source:, namespace:)
+      Kangaru.eager_load(Initialisers)
+
+      namespace.extend InjectedMethods
+    end
+  end
+end

data/lib/kangaru/initialisers/rspec.rb

@@ -0,0 +1,11 @@
+module Kangaru
+  module Initialisers
+    module RSpec
+      if Object.const_defined?(:RSpec)
+        ::RSpec.configure do
+          Kangaru.env = :test
+        end
+      end
+    end
+  end
+end

data/lib/kangaru/injected_methods.rb

@@ -0,0 +1,23 @@
+module Kangaru
+  module InjectedMethods
+    def run!(*argv)
+      Kangaru.application.run!(*argv)
+    end
+
+    def config
+      Kangaru.application.config
+    end
+
+    def configure(env = nil, &)
+      Kangaru.application.configure(env, &)
+    end
+
+    def apply_config!
+      Kangaru.application.apply_config!
+    end
+
+    def database
+      Kangaru.application.database
+    end
+  end
+end

data/lib/kangaru/model.rb

@@ -0,0 +1,7 @@
+module Kangaru
+  Model = Class.new(Sequel::Model) do
+    include Concerns::Validatable
+  end
+
+  Model.def_Model(self)
+end

data/lib/kangaru/patches/constantise.rb

@@ -0,0 +1,11 @@
+module Kangaru
+  module Patches
+    module Constantise
+      refine String do
+        def constantise(root: Object)
+          Inflectors::Constantiser.constantise(self, root:)
+        end
+      end
+    end
+  end
+end

data/lib/kangaru/patches/inflections.rb

@@ -0,0 +1,23 @@
+module Kangaru
+  module Patches
+    module Inflections
+      refine String do
+        def to_class_name
+          Inflectors::ClassInflector.inflect(self)
+        end
+
+        def to_constant_name
+          Inflectors::ConstantInflector.inflect(self)
+        end
+
+        def to_snakecase
+          Inflectors::SnakecaseInflector.inflect(self)
+        end
+
+        def to_humanised
+          Inflectors::HumanInflector.inflect(self)
+        end
+      end
+    end
+  end
+end

data/lib/kangaru/patches/source.rb

@@ -0,0 +1,11 @@
+module Kangaru
+  module Patches
+    module Source
+      refine Module do
+        def source
+          Object.const_source_location(name || raise)&.first || raise
+        end
+      end
+    end
+  end
+end

data/lib/kangaru/patches/symboliser.rb

@@ -0,0 +1,29 @@
+module Kangaru
+  module Patches
+    module Symboliser
+      refine Hash do
+        def symbolise
+          to_h do |key, value|
+            value = case value
+                    when Array, Hash then value.symbolise
+                    else value
+                    end
+
+            [key.to_sym, value]
+          end
+        end
+      end
+
+      refine Array do
+        def symbolise
+          map do |value|
+            case value
+            when Array, Hash then value.symbolise
+            else value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kangaru/path_parser.rb

@@ -0,0 +1,35 @@
+module Kangaru
+  class PathParser
+    attr_reader :path
+
+    def initialize(path)
+      @path = path
+    end
+
+    def controller
+      match(:controller)
+    end
+
+    def action
+      match(:action, cast: :to_sym)
+    end
+
+    def id
+      match(:id, cast: :to_i)
+    end
+
+    private
+
+    MATCHERS = {
+      controller: %r{/(.*)/[A-z]+(/\d+)?$},
+      action: %r{^.*/([A-z]+)(/\d+)?$},
+      id: %r{^.*/(\d+)$}
+    }.freeze
+
+    def match(key, cast: :to_s)
+      return unless (value = path.scan(MATCHERS[key]).flatten.first)
+
+      value.send(cast)
+    end
+  end
+end