alki 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: acebb8f2a073f60c659eb7b994778f3717c140c9
+  data.tar.gz: c6bf4c35dbe97001bfed4b772a84e811b7200b93
+SHA512:
+  metadata.gz: 623bacc9055973a92a710f2a7fe7235cdea0da93d5f434445b9b931ccc2c4ea51f261ba6715f19d95a5bd90ac5b496e05ce3f0e127877d1e45814863b0bd03d2
+  data.tar.gz: f33554183dc94171bb8191908745f218cf6bc5215e2125a9d9de4fc9cce1708a25799670e00833050fa83d54201fb02fb4f290f665881094f598870761c5476e

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.iml

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'minitest', '~> 5.4.2'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Matt Edlefsen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+# base.alki
+
+Basic library for creating applications.
+

data/Rakefile

@@ -0,0 +1,29 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.name = 'test:unit'
+  t.pattern = "test/unit/*_test.rb"
+end
+
+Rake::TestTask.new do |t|
+  t.name = 'test:feature'
+  t.pattern = "test/feature/*_test.rb"
+end
+
+Rake::TestTask.new do |t|
+  t.name = 'test:integration'
+  t.pattern = "test/integration/*_test.rb"
+end
+
+Rake::TestTask.new do |t|
+  t.name = 'test:page'
+  t.pattern = "test/page/*_test.rb"
+end
+
+Rake::TestTask.new do |t|
+  t.name = 'test'
+  t.pattern = "test/*/*_test.rb"
+end
+
+task default: [:test]

data/alki.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'alki/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "alki"
+  spec.version       = Alki::VERSION
+  spec.authors       = ["Matt Edlefsen"]
+  spec.email         = ["matt@xforty.com"]
+  spec.summary       = %q{Base library for building applications.}
+  spec.description   = %q{Base library for building applications. Provides tools for organizing and connection application units.}
+  spec.homepage      = "https://gitlab.xforty.com/matt/base-alki"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir        = 'exe'
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", '~> 10.0'
+end

data/lib/alki/class_builder.rb

@@ -0,0 +1,41 @@
+require 'alki/dsl_builder'
+
+module Alki
+  class ClassBuilder
+    def initialize(*dsl_factories)
+      @dsl_factories = dsl_factories.flatten
+    end
+
+    def build(name=nil,&blk)
+      self.class.build(name,@dsl_factories,&blk)
+    end
+
+    def self.build(name=nil,dsl_factories,&blk)
+      Class.new.tap do |c|
+        builder = -> {
+          Module.new.tap do |m|
+            m.define_singleton_method :klass do
+              c
+            end
+          end
+        }
+        m = DslBuilder.build(c,dsl_factories,
+                         builder: builder,exec: :class_exec,
+                         &blk)
+        c.include m
+        if name
+          *ans, ln = name.to_s.split(/::/)
+          parent = Object
+          ans.each do |a|
+            unless parent.const_defined? a
+              parent.const_set a, Module.new
+            end
+            parent = parent.const_get a
+          end
+
+          parent.const_set ln, c
+        end
+      end
+    end
+  end
+end

data/lib/alki/dsl_builder.rb

@@ -0,0 +1,43 @@
+module Alki
+  class DslBuilder
+    def initialize(*dsl_factories,builder: nil, exec: nil)
+      @builder = builder
+      @exec = exec
+      @dsl_factories = dsl_factories.flatten
+    end
+
+    def build(obj,&blk)
+      self.class.build(obj,@dsl_factories,
+                       builder: @builder,
+                       exec: @exec,
+                       &blk)
+    end
+
+    def self.build(obj,dsl_factories,builder: nil, exec: nil, &blk)
+      builder ||= Object.method(:new)
+      exec ||= :instance_exec
+      unless dsl_factories.is_a?(Array)
+        dsl_factories = [dsl_factories]
+      end
+      builder = builder.call
+      dsls = []
+      dsl_factories.each do |dsl_factory|
+        if dsl_factory.respond_to? :new_dsl
+          dsl = dsl_factory.new_dsl obj
+        else
+          dsl = dsl_factory.new obj
+        end
+        dsl.dsl_methods.each do |method_name|
+          method = dsl.method(method_name)
+          builder.define_singleton_method method_name do |*args,&blk|
+            method.call *args, &blk
+          end
+        end
+        dsls << dsl
+      end
+      builder.send(exec,&blk)
+      dsls.each {|dsl| dsl.finalize if dsl.respond_to? :finalize }
+      builder
+    end
+  end
+end

data/lib/alki/group_builder.rb

@@ -0,0 +1,25 @@
+require 'alki/group_dsl'
+require 'alki/dsl_builder'
+
+module Alki
+  class GroupBuilder
+    def self.build(loader,obj = {},&dsl)
+      Alki::GroupBuilder.new(loader).build(obj,&dsl)
+      obj
+    end
+
+    def initialize(loader)
+      @loader = loader
+      @builder = Alki::DslBuilder.new(self)
+    end
+
+    def new_dsl(obj)
+      GroupDsl.new(obj,loader: @loader, group_builder: @builder)
+    end
+
+    def build(group={},&dsl)
+      @builder.build(group,&dsl)
+      group
+    end
+  end
+end

data/lib/alki/group_dsl.rb

@@ -0,0 +1,98 @@
+require 'alki/util'
+
+module Alki
+  class GroupDsl
+    def initialize(root,group_builder:,loader:)
+      @root = root
+      @group_builder = group_builder
+      @loader = loader
+    end
+
+    def dsl_methods
+      [:set,:service,:factory,:load,:import,:group,:overlay,:clear_overlays]
+    end
+
+    def set(name,value=nil,&blk)
+      service name, &(blk || -> { value })
+    end
+
+    def service(name,&blk)
+      name = name.to_sym
+      @root[name] = {
+        type: :service,
+        block: blk
+      }
+    end
+
+    def factory(name,&blk)
+      name = name.to_sym
+      @root[name] = {
+        type: :factory,
+        block: blk
+      }
+    end
+
+    def import(name)
+      instance_exec &@loader.load(name.to_s)
+    end
+
+    def load(name)
+      group(name.to_sym) do
+        import(name)
+      end
+    end
+
+    def package(name,pkg,klass=nil,&blk)
+      if pkg.is_a? String
+        require pkg
+        if klass == nil
+          pkg = Alki::Util.classify(pkg)
+        else
+          pkg = klass
+        end
+      end
+      if pkg.is_a? Class
+        pkg = pkg.new
+      end
+      if pkg.response_to? :package_definition
+        pkg = pkg.package_definition
+      end
+      unless pkg.is_a? Hash
+        raise "Invalid package: #{pkg.inspect}"
+      end
+      name = name.to_sym
+      overrides = {}
+      @group_builder.build(overrides,&blk) if blk
+      overrides[:original] = {
+        type: :package,
+        children: pkg,
+        overrides: {}
+      }
+      @root[name] = {
+        type: :package,
+        children: pkg,
+        overrides: overrides
+      }
+    end
+
+    def group(name,&blk)
+      name = name.to_sym
+      children = {}
+      @group_builder.build(children,&blk)
+      @root[name] = {
+        type: :group,
+        children: children
+      }
+    end
+
+    def overlay(&blk)
+      @root['overlays'] ||= []
+      @root['overlays'] << blk
+    end
+
+    def clear_overlays
+      @root['overlays'] ||= []
+      @root['overlays'] << :clear
+    end
+  end
+end

data/lib/alki/loader.rb

@@ -0,0 +1,32 @@
+module Alki
+  class Loader
+    def self.load(config_file)
+      Fiber.new do
+        Kernel.load config_file
+        Thread.current[:alki_loader_current]
+      end.resume
+    end
+
+    def initialize(root_dir)
+      @root_dir = root_dir
+    end
+
+    def load_all
+      Dir[File.join(@root_dir,'**','*.rb')].inject({}) do |h,path|
+        file = path.gsub(File.join(@root_dir,''),'').gsub(/\.rb$/,'')
+        h.merge!(file => Loader.load(path))
+      end
+    end
+
+    def load(file)
+      Loader.load File.expand_path("#{file}.rb",@root_dir)
+    end
+  end
+end
+
+module Kernel
+  def Alki(&blk)
+    Thread.current[:alki_loader_current] = blk if blk
+    ::Alki
+  end
+end

data/lib/alki/overlay_delegator.rb

@@ -0,0 +1,33 @@
+module Alki
+  class OverlayDelegator
+    def initialize(name,obj,overlay)
+      @name = name
+      @obj = obj
+      @overlay = overlay
+      @key = :"#{obj.object_id}:#{overlay.object_id}"
+    end
+
+    def respond_to_missing(method,include_private = false)
+      unless Thread.current[@key]
+        Thread.current[@key] = true
+        if @overlay.respond_to? :overlay_respond_to?
+          @overlay.overlay_respond_to? @obj, method, include_private
+        else
+          @obj.respond_to? method, include_private
+        end
+        Thread.current[@key] = false
+      end
+    end
+
+    def method_missing(method,*args,&blk)
+      if Thread.current[@key]
+        res = @obj.send method, *args, &blk
+      else
+        Thread.current[@key] = true
+        res = @overlay.call @name, @obj, method, *args, &blk
+        Thread.current[@key] = false
+      end
+      res
+    end
+  end
+end

data/lib/alki/package.rb

@@ -0,0 +1,33 @@
+require 'alki/package_executor'
+require 'alki/package_processor'
+
+module Alki
+  class Package
+    def initialize(package_definition)
+      @def = package_definition
+      @cache = {}
+    end
+
+    def root
+      @root ||= __executor__.call @def, @cache, []
+    end
+
+    def package_definition
+      @def
+    end
+
+    def respond_to_missing?(name,include_all)
+      root.respond_to? name
+    end
+
+    def method_missing(name,*args,&blk)
+      root.send name, *args, &blk
+    end
+
+    private
+
+    def __executor__
+      @executor ||= Alki::PackageExecutor.new Alki::PackageProcessor.new
+    end
+  end
+end

data/lib/alki/package_builder.rb

@@ -0,0 +1,2 @@
+module Alki
+end

data/lib/alki/package_executor.rb

@@ -0,0 +1,120 @@
+require 'alki/service_delegator'
+require 'alki/overlay_delegator'
+
+module Alki
+  class PackageExecutor
+    def initialize(processor)
+      @processor = processor
+    end
+
+    def call(pkg,cache,path,*args,&blk)
+      elem = @processor.lookup(pkg,path)
+      triple = [pkg,cache,elem]
+      case elem[:type]
+        when :service
+          service triple, path, *args
+        when :factory
+          factory triple, path, *args, &blk
+        when :group
+          group triple, *args
+      end
+    end
+
+    def service(triple,path)
+      pkg,cache,elem = triple
+      unless cache[path]
+        with_scope_context(triple) do |ctx,blk|
+          cache[path] = apply_overlays triple,path, ctx.instance_exec(&blk)
+        end
+      end
+      cache[path]
+    end
+
+    def apply_overlays((pkg,cache,elem),path,obj)
+      elem[:overlays].inject(obj) do |obj,overlay_elem|
+        unless cache[overlay_elem[:block]]
+          with_scope_context([pkg,cache,overlay_elem]) do |ctx,blk|
+            cache[overlay_elem[:block]] = ctx.instance_exec(&blk)
+          end
+        end
+        local_path = path[overlay_elem[:scope][:root].size..-1].join('.')
+        Alki::OverlayDelegator.new local_path,obj, cache[overlay_elem[:block]]
+      end
+    end
+
+    def factory(triple,path,*args,&blk)
+      pkg,cache,elem = triple
+      unless cache[path]
+        with_scope_context(triple) do |ctx,blk|
+          cache[path] = ctx.instance_exec(&blk)
+        end
+      end
+      cache[path].call *args, &blk
+    end
+
+    def group((pkg,cache,elem))
+      proc = -> (name,*args,&blk) {
+        call pkg, cache, elem[:children][name], *args, &blk
+      }
+
+      GroupContext.new(proc,elem[:children].keys)
+    end
+
+    def with_scope_context((pkg,cache,elem))
+      proc = -> (name,*args,&blk) {
+        call pkg, cache, elem[:scope][name], *args, &blk
+      }
+
+      yield ServiceContext.new(proc,elem[:scope].keys), elem[:block]
+    end
+
+    class Context
+      def initialize(executor,scope)
+        @executor = executor
+        @scope = scope
+      end
+
+      def respond_to_missing?(name,include_all)
+        @scope.include? name
+      end
+
+      def method_missing(name,*args,&blk)
+        if @scope.include? name
+          @executor.call name, *args, &blk
+        else
+          super
+        end
+      end
+    end
+
+    class ServiceContext < Context
+      def lookup(path)
+        unless path.is_a?(String) or path.is_a?(Symbol)
+          raise ArgumentError.new("lookup can only take Strings or Symbols")
+        end
+        path.to_s.split('.').inject(self) do |group,name|
+          raise "Invalid lookup path" unless group.is_a? Context
+          group.send name.to_sym
+        end
+      end
+
+      def lazy(path)
+        unless path.is_a?(String) or path.is_a?(Symbol)
+          raise ArgumentError.new("lazy can only take Strings or Symbols")
+        end
+        Alki::ServiceDelegator.new root, path
+      end
+    end
+
+    class GroupContext < Context
+      def lookup(path)
+        unless path.is_a?(String) or path.is_a?(Symbol)
+          raise ArgumentError.new("lookup can only take Strings or Symbols")
+        end
+        path.to_s.split('.').inject(self) do |group,name|
+          group.send name.to_sym
+        end
+      end
+    end
+  end
+end