rodakase 0.0.1

data/lib/rodakase/component.rb

@@ -0,0 +1,40 @@
+require 'inflecto'
+
+module Rodakase
+  def self.Component(input)
+    Component.new(Component.identifier(input), Component.path(input))
+  end
+
+  class Component
+    IDENTIFIER_SEPARATOR = '.'.freeze
+    PATH_SEPARATOR = '/'.freeze
+
+    attr_reader :identifier, :path, :file
+
+    def self.identifier(input)
+      input.gsub(PATH_SEPARATOR, IDENTIFIER_SEPARATOR)
+    end
+
+    def self.path(input)
+      input.gsub(IDENTIFIER_SEPARATOR, PATH_SEPARATOR)
+    end
+
+    def initialize(identifier, path)
+      @identifier = identifier
+      @path = path
+      @file = "#{path}.rb"
+    end
+
+    def name
+      Inflecto.camelize(path)
+    end
+
+    def constant
+      Inflecto.constantize(name)
+    end
+
+    def instance(*args)
+      constant.new(*args)
+    end
+  end
+end

data/lib/rodakase/config.rb

@@ -0,0 +1,21 @@
+require 'yaml'
+
+module Rodakase
+  class Config
+    extend Dry::Configurable
+
+    def self.load(root, env)
+      path = root.join('config').join('application.yml')
+
+      return unless File.exist?(path)
+
+      yaml = YAML.load_file(path)
+
+      yaml.fetch(env.to_s).each do |key, value|
+        setting key.downcase.to_sym, ENV.fetch(key, value)
+      end
+
+      config
+    end
+  end
+end

data/lib/rodakase/container.rb

@@ -0,0 +1,127 @@
+require 'inflecto'
+require 'dry-container'
+require 'dry-auto_inject'
+
+require 'rodakase/component'
+require 'rodakase/config'
+
+module Rodakase
+  class Container
+    extend Dry::Container::Mixin
+
+    setting :env, ENV.fetch('RACK_ENV', :development).to_sym
+    setting :root, Pathname.pwd.freeze
+    setting :auto_register
+    setting :app
+
+    def self.configure(env = config.env, &block)
+      if !configured?
+        super() do |config|
+          app_config = Config.load(root, env)
+          config.app = app_config if app_config
+        end
+
+        load_paths!('core')
+
+        @_configured = true
+      end
+
+      yield(self)
+
+      self
+    end
+
+    def self.configured?
+      @_configured
+    end
+
+    def self.finalize!(&block)
+      yield(self) if block
+
+      Dir[root.join('core/boot/**/*.rb')].each(&method(:require))
+
+      if config.auto_register
+        Array(config.auto_register).each(&method(:auto_register!))
+      end
+
+      freeze
+    end
+
+    def self.import_module
+      auto_inject = Dry::AutoInject(self)
+
+      -> *keys {
+        keys.each { |key| load_component(key) unless key?(key) }
+        auto_inject[*keys]
+      }
+    end
+
+    def self.auto_register!(dir, &block)
+      dir_root = root.join(dir.to_s.split('/')[0])
+
+      Dir["#{root}/#{dir}/**/*.rb"].each do |path|
+        component_path = path.to_s.gsub("#{dir_root}/", '').gsub('.rb', '')
+        component = Rodakase.Component(component_path)
+
+        next if key?(component.identifier)
+
+        Kernel.require component.path
+
+        if block
+          register(component.identifier, yield(component.constant))
+        else
+          register(component.identifier) { component.instance }
+        end
+      end
+
+      self
+    end
+
+    def self.boot!(name)
+      require "core/boot/#{name}.rb"
+    end
+
+    def self.require(*paths)
+      paths
+        .flat_map { |path|
+          path.include?('*') ? Dir[root.join(path)] : root.join(path)
+        }
+        .each { |path|
+          Kernel.require path
+        }
+    end
+
+    def self.load_component(key)
+      require_component(key) { |klass| register(key) { klass.new } }
+    end
+
+    def self.require_component(key, &block)
+      component = Rodakase.Component(key)
+      path = load_paths.detect { |p| p.join(component.file).exist? }
+
+      if path
+        Kernel.require component.path
+        yield(component.constant) if block
+      else
+        raise ArgumentError, "could not resolve require file for #{key}"
+      end
+    end
+
+    def self.root
+      config.root
+    end
+
+    def self.load_paths!(*dirs)
+      dirs.map(&:to_s).each do |dir|
+        path = root.join(dir)
+        load_paths << path
+        $LOAD_PATH.unshift(path.to_s)
+      end
+      self
+    end
+
+    def self.load_paths
+      @_load_paths ||= []
+    end
+  end
+end

data/lib/rodakase/transaction.rb

@@ -0,0 +1,43 @@
+require 'delegate'
+require 'transflow'
+
+require 'rodakase/transaction/result'
+require 'rodakase/transaction/matcher'
+
+module Rodakase
+  module Transaction
+    class Flow
+      extend Forwardable
+
+      def_delegator :@transaction, :subscribe
+
+      attr_reader :transaction
+
+      def initialize(transaction)
+        @transaction = transaction
+      end
+
+      def call(*args, &block)
+        result = transaction.call(*args)
+
+        if block
+          yield(Matcher.new(result))
+        else
+          result
+        end
+      end
+    end
+
+    class Composer
+      attr_reader :container
+
+      def initialize(container)
+        @container = container
+      end
+
+      def define(&block)
+        Flow.new(Transflow(container: container, &block))
+      end
+    end
+  end
+end

data/lib/rodakase/transaction/matcher.rb

@@ -0,0 +1,31 @@
+module Rodakase
+  module Transaction
+    class Matcher
+      attr_reader :result
+
+      class Error
+        attr_reader :result
+
+        def initialize(result)
+          @result = result
+        end
+
+        def on(code, &block)
+          yield(result.value) if result.code == code
+        end
+      end
+
+      def initialize(result)
+        @result = result
+      end
+
+      def success(&block)
+        yield(result.value) if result.success?
+      end
+
+      def failure(&block)
+        yield(Error.new(result)) if result.failure?
+      end
+    end
+  end
+end

data/lib/rodakase/transaction/result.rb

@@ -0,0 +1,52 @@
+module Rodakase
+  module Transaction
+    class Success
+      attr_reader :value
+
+      def initialize(value)
+        @value = value
+      end
+
+      def fmap
+        Success.new(yield(value))
+      end
+
+      def success?
+        true
+      end
+
+      def failure?
+        false
+      end
+    end
+
+    class Failure
+      attr_reader :code, :error
+      alias_method :value, :error
+
+      def initialize(*args)
+        @code, @error = args
+      end
+
+      def fmap
+        self
+      end
+
+      def success?
+        false
+      end
+
+      def failure?
+        true
+      end
+    end
+
+    def self.Failure(code, error)
+      Failure.new(code, error)
+    end
+
+    def self.Success(value)
+      Success.new(value)
+    end
+  end
+end

data/lib/rodakase/version.rb

@@ -0,0 +1,3 @@
+module Rodakase
+  VERSION = '0.0.1'.freeze
+end

data/lib/rodakase/view.rb

@@ -0,0 +1,2 @@
+require 'rodakase/view/renderer'
+require 'rodakase/view/layout'

data/lib/rodakase/view/layout.rb

@@ -0,0 +1,98 @@
+require 'dry-configurable'
+require 'dry-equalizer'
+
+require 'rodakase/view/part'
+require 'rodakase/view/renderer'
+
+module Rodakase
+  module View
+    class Layout
+      include Dry::Equalizer(:config)
+
+      Scope = Struct.new(:page)
+
+      DEFAULT_SCOPE = Object.new.freeze
+      DEFAULT_DIR = 'layouts'.freeze
+
+      extend Dry::Configurable
+
+      setting :engine
+      setting :root
+      setting :renderer
+      setting :name
+      setting :template
+      setting :scope
+
+      def self.configure(&block)
+        super do |config|
+          yield(config)
+
+          unless config.renderer
+            config.renderer = Renderer.new(config.root, engine: config.engine)
+          end
+        end
+      end
+
+      attr_reader :config, :renderer, :scope,
+        :layout_dir, :layout_path, :template_path
+
+      def initialize
+        @config = self.class.config
+        @renderer = @config.renderer
+        @layout_dir = DEFAULT_DIR
+        @layout_path = "#{layout_dir}/#{config.name}"
+        @template_path = config.template
+        @scope = config.scope
+      end
+
+      def call(options = {})
+        renderer.(layout_path, layout_scope(options)) do
+          renderer.(template_path, template_scope(options))
+        end
+      end
+
+      def layout_scope(options)
+        Scope.new(layout_part(:page, options.fetch(:scope, scope)))
+      end
+
+      def template_scope(options)
+        parts(locals(options))
+      end
+
+      def locals(options)
+        options.fetch(:locals, {})
+      end
+
+      def parts(locals)
+        return DEFAULT_SCOPE unless locals.any?
+
+        part_hash = locals.each_with_object({}) do |(key, value), result|
+          part =
+            case value
+            when Array
+              el_key = Inflecto.singularize(key).to_sym
+              template_part(key, value.map { |element| template_part(el_key, element) })
+            else
+              template_part(key, value)
+            end
+
+          result[key] = part
+        end
+
+        part(template_path, part_hash)
+      end
+
+      def layout_part(name, value)
+        part(layout_dir, name => value)
+      end
+
+      def template_part(name, value)
+        part(template_path, name => value)
+      end
+
+      def part(dir, value)
+        Part.new(renderer.chdir(dir), value)
+      end
+    end
+  end
+end

data/lib/rodakase/view/part.rb

@@ -0,0 +1,53 @@
+require 'dry-equalizer'
+
+module Rodakase
+  module View
+    class Part
+      include Dry::Equalizer(:renderer, :_data, :_value)
+
+      attr_reader :renderer, :_data, :_value
+
+      def initialize(renderer, data)
+        @renderer = renderer
+        @_data = data
+        @_value = data.values[0]
+      end
+
+      def [](key)
+        _value[key]
+      end
+
+      def each(&block)
+        _value.each(&block)
+      end
+
+      def render(path, &block)
+        renderer.render(path, self, &block)
+      end
+
+      def template?(name)
+        renderer.lookup("_#{name}")
+      end
+
+      def respond_to_missing?(meth, include_private = false)
+        super || _data.key?(meth) || template?(meth)
+      end
+
+      private
+
+      def method_missing(meth, *args, &block)
+        template_path = template?(meth)
+
+        if template_path
+          render(template_path, &block)
+        elsif _data.key?(meth)
+          _data[meth]
+        elsif _value.respond_to?(meth)
+          _value.public_send(meth, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end