alki-reload 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 81d6fa79f6cda460001792bc044bb0e249f2875a
-  data.tar.gz: 684d8997a8faf0aa288373adf5f2e94797e1cf7e
+  metadata.gz: b05597e13de69db0fcbc34fd150c89fde3647a24
+  data.tar.gz: 6e7161d23ae9d232b7e7c0e5309ca6e3b49871a6
 SHA512:
-  metadata.gz: 5f98c6a378a333915e1520e88e1d6253d02bf467f53a5b674b2d5791386b20de8b8ffe8cda59fe7ccb1659c53ca85cbb44d692a6c6a3f0d643732146028ac43d
-  data.tar.gz: c5bcbb7022610e6b1e27f1257c9b91d324cbe68b24a2c8cbcc95c19fb80fd9d43858b6b01d93346607d237b20b21e25df2b938cf8d427ecf068c82e216d043f2
+  metadata.gz: 672a296eadf628c9cbb3a5a3f53766d1c67d48b22e30ff53d865b89f151897197219643bb336c2f892333aed1671a230948763bd1dc34eed0a13e83067ef19c0
+  data.tar.gz: 751e2cc7bcb01466edb10ddb95d15017b2e3f53732d99f75f4e6eaab333a7de28c8ec629955bc8fe625c9cbc9f9438250ed2728d624af3ec03c9dd9e2e522ed5

data/README.adoc

@@ -0,0 +1,162 @@
+= Alki::Reload
+
+Provides auto-reload feature to Alki projects. Like the auto-reload feature in Ruby on Rails, when
+enabled it will monitor source files and whenever a change is detected, will reload the project.
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem 'alki-reload'
+----
+
+And then execute:
+
+[source]
+----
+$ bundle
+----
+
+Or install it yourself as:
+
+[source]
+----
+$ gem install alki-reload
+----
+
+== Usage
+
+To use Alki::Reload in an Alki project, it must be mounted in the assembly. By default, Alki::Reload
+will not actively watch files or actively hook into services. Setting `enable` to true will enable both.
+
+.config/assembly.rb
+```ruby
+Alki do
+  mount :reloader, 'alki/reload' do
+    set(:enable) { true }
+  end
+# ...
+end
+```
+
+### Conditional usage
+
+Because enabling reload can have a performance impact, typically it's only enabled when in some sort
+of development mode.
+
+.config/assembly.rb
+```ruby
+Alki do
+  set(:development?) { ENV['APP_ENV'] != 'production' }
+
+  mount :reloader, 'alki/reload' do
+    set(:enable) { development? }
+  end
+# ...
+end
+```
+
+### Main Loops
+
+A problem that naturally comes up is how to reload an application, while the application is running.
+Most applications, when running, spend most of their time inside a "main loop". If it's a server,
+it might be the loop listening for incoming data, if it's a console application it might be the loop
+waiting for user input.
+
+Because the main loop is always running, there is never an opportunity to reload it. Alki::Reload
+provides a feature to help work around this.
+
+First off, because the service the main loop is in can't be reloaded, it should be made as small and
+simple as possible, offloading all other functionality into secondary services that it takes as
+dependencies.
+
+Second, it should be tagged with a `main_loop` tag. By tagging your main loop service, Alki::Reload will
+actively hook into the service and wrap it's dependencies with wrapper objects that will pick up the
+new version of those dependencies whenever the project is reloaded.
+
+Alki::Loader must be enabled for this feature to be active.
+
+.config/assembly.rb
+```ruby
+Alki do
+  mount :reloader, 'alki/reload', enable: true
+
+  set :prompt, "> "
+  service :handler do
+    -> line { puts line }
+  end
+
+  tag :main_loop
+  service :main do
+    require 'readline_loop'
+    ReadlineLoop.new prompt, handler
+  end
+  # ...
+end
+```
+
+.lib/readline_loop.rb
+```ruby
+require 'readline'
+class ReadlineLoop
+  def initialize(prompt, handler)
+    @prompt = prompt
+    @handler = handler
+  end
+
+  def run
+    while line = Readline.readline(@prompt,true)
+      @handler.call line
+    end
+  end
+end
+```
+
+In this example, our main loop is `main.run`. Because the `main` service is tagged even while it
+is running the prompt and handler can be changed and reloaded.
+
+### Watched Directories
+
+By default, `lib`, `config` and any files or directories configured in
+https://github.com/alki-project/alki-loader[Alki::Loader] are watched.
+
+Additional directories can be added by overriding the dirs element. Additional directories must also
+be in `$LOAD_PATH`.
+
+.config/assembly.rb
+```ruby
+Alki do
+  mount :reloader, 'alki/reload' do
+    set(:enable) { true }
+    set(:dirs) { original.dirs + ['app'] }
+  end
+# ...
+end
+```
+
+### Manual Reloading
+
+In addition to watching for filesystem changes, a project can be reloaded manually by calling
+the `reload` func in the reloader. This works even when the reloader is not enabled.
+
+.config/assembly.rb
+```ruby
+Alki do
+  mount :reloader, 'alki/reload'
+# ...
+end
+```
+
+```ruby
+instance.reloader.reload # reload instance
+```
+
+== Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/alki-project/alki-reload. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the http://contributor-covenant.org[Contributor Covenant] code of conduct.
+
+== License
+
+The gem is available as open source under the terms of the http://opensource.org/licenses/MIT[MIT License].

data/alki-reload.gemspec

@@ -23,5 +23,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_dependency "listen", "~> 3.0"
-  spec.add_dependency "alki", "~> 0.9", ">= 0.9.1"
+  spec.add_dependency "alki", "~> 0.10"
 end

data/config/assembly.rb

@@ -3,7 +3,15 @@ Alki do
     root.assembly_instance.__reload__
   end
 
-  set :watch, false
+  set :enable, false
+
+  set :main_loops do
+    enable
+  end
+
+  set :watch do
+    enable
+  end
 
   set :dirs do
     ['lib']
@@ -19,13 +27,26 @@ Alki do
     end
   end
 
+  reference_overlay '%main_loop', :reloadable_reference
+
+  factory :reloadable_reference do
+    require 'alki/reload/reloadable_delegator'
+    -> (ref) {
+      if main_loops
+        Alki::Reload::ReloadableDelegator.new(root.assembly_instance,ref)
+      else
+        ref.call
+      end
+    }
+  end
+
   service :handlers do
-    [dsl_handler,load_path_handler]
+    [loader_handler,load_path_handler]
   end
 
-  service :dsl_handler do
-    require 'alki/reload/dsl_handler'
-    Alki::Reload::DslHandler.new root_dir
+  service :loader_handler do
+    require 'alki/reload/loader_handler'
+    Alki::Reload::LoaderHandler.new root_dir
   end
 
   service :load_path_handler do

data/lib/alki/reload/load_path_handler.rb

@@ -10,7 +10,7 @@ module Alki
       def handle_path(path)
         @dirs.each do |dir|
           if path.start_with? dir
-            return path[dir.size..-1].match(%r{(?:(.*)/)?(.*).rb})[1..2]
+            return path[dir.size..-1].chomp('.rb')
           end
         end
         nil

data/lib/alki/reload/{dsl_handler.rb → loader_handler.rb}

@@ -1,8 +1,8 @@
-require 'alki/dsl/registry'
+require 'alki/loader'
 
 module Alki
   module Reload
-    class DslHandler
+    class LoaderHandler
       def initialize(root_dir)
         @root_dir = File.join(root_dir,'')
       end
@@ -11,17 +11,15 @@ module Alki
         dirs.each do |dir|
           dir = File.join(dir,'')
           if path.start_with? dir
-            entry = Alki::Dsl::Registry.lookup(path)
-            if entry && entry.data[:prefix] && entry.data[:name]
-              return [entry.data[:prefix], entry.data[:name]]
-            end
+            name = Alki::Loader.lookup_name path
+            return name if name
           end
         end
         nil
       end
 
       def dirs
-        Alki::Dsl::Registry.registered_dirs.select do |d|
+        Alki::Loader.registered_paths.select do |d|
           d.start_with?(@root_dir)
         end
       end

data/lib/alki/reload/reloadable_delegator.rb

@@ -0,0 +1,30 @@
+require 'delegate'
+
+module Alki
+  module Reload
+    class ReloadableDelegator < Delegator
+      def initialize(instance,ref)
+        @instance = instance
+        @ref = ref
+      end
+
+      def __getobj__
+        if !@obj || @instance_version != @instance.__version__
+          @ref.executor = @instance.assembly_executor
+          @obj = @ref.call
+          @instance_version = @instance.__version__
+        end
+        @obj
+      end
+
+      def method_missing(method,*args,&blk)
+        ref_meth = :"__reference_#{method}__"
+        if respond_to?(ref_meth,true)
+          ReloadableDelegator.new @instance, super(ref_meth, *args, &blk)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/alki/reload/unloader.rb

@@ -1,5 +1,4 @@
 require 'alki/support'
-require 'alki/dsl/registry'
 
 module Alki
   module Reload
@@ -16,8 +15,9 @@ module Alki
           if path.end_with?('.rb')
             result = @handlers.lazy.map{|h| h.handle_path path }.find{|r| r != nil}
             if result
-              add_const consts, *result
-              files << path
+              if add_const consts, result
+                files << path
+              end
             end
           end
         end
@@ -33,9 +33,15 @@ module Alki
 
       private
 
-      def add_const(consts,parent,name)
-        unless whitelisted? parent, name
-          parent = parent ? Alki::Support.load_class(parent) : Object
+      def add_const(consts,name)
+        unless @whitelist.include? name
+          md = name.match(%r{(.*)/(.*)})
+          if md
+            parent = Alki::Support.constantize Alki::Support.classify md[1]
+            name = md[2]
+          else
+            parent = Object
+          end
           name = Alki::Support.classify(name).to_sym
           if parent && parent.is_a?(Module) && parent.const_defined?(name,false)
             consts << [parent,name]
@@ -43,10 +49,6 @@ module Alki
           end
         end
       end
-
-      def whitelisted?(parent,name)
-        @whitelist.include?(parent ? File.join(parent,name) : name)
-      end
     end
   end
 end

data/lib/alki/reload/version.rb

@@ -1,5 +1,5 @@
 module Alki
   module Reload
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alki-reload
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Matt Edlefsen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-20 00:00:00.000000000 Z
+date: 2016-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,20 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.9.1
+        version: '0.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.9'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.9.1
+        version: '0.10'
 description: 
 email:
 - matt.edlefsen@gmail.com
@@ -83,15 +77,16 @@ files:
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
-- README.md
+- README.adoc
 - Rakefile
 - alki-reload.gemspec
 - config/assembly.rb
 - lib/alki/reload.rb
 - lib/alki/reload/assembly_delegator.rb
-- lib/alki/reload/dsl_handler.rb
 - lib/alki/reload/listen_watcher.rb
 - lib/alki/reload/load_path_handler.rb
+- lib/alki/reload/loader_handler.rb
+- lib/alki/reload/reloadable_delegator.rb
 - lib/alki/reload/reloader.rb
 - lib/alki/reload/unloader.rb
 - lib/alki/reload/version.rb

data/README.md

@@ -1,41 +0,0 @@
-# Alki::Reload
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/alki/reload`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'alki-reload'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install alki-reload
-
-## Usage
-
-TODO: Write usage instructions here
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/alki-reload. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-
-
-## License
-
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-