grape-reload 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 90005752e374515209acc7d30cf36d3e458645bd
+  data.tar.gz: 54b9b236aaaadcd77d0a313a54c015730f81e648
+SHA512:
+  metadata.gz: 31c279a890f45ccf696a7ee25eaa7bafdea50cb99a8134aced2d3dd85a2d188b970444a5077068687bdcdf9a6c0111bd7789cdd946ff39f74e85e97dbc7ba94b
+  data.tar.gz: 033a629434a32aae7503e27307ea69548d3b1ee7ce8b61e6de370c98c6f4894e9262ae8cba0b4aec4eaa107f9104f39d0b6681467017dd736661a67404ba91a9

data/.gitignore

@@ -0,0 +1,24 @@
+*.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
+.ruby-*
+.idea

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+cache: bundler
+
+rvm:
+  - jruby
+  - 2.0.0
+  - 2.1.2
+
+script: 'bundle exec rake'
+
+notifications:
+  email:
+    recipients:
+      - amar4enko@gmail.com
+    on_failure: change
+    on_success: never

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in grape-reload.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,13 @@
+notification :terminal_notifier
+
+guard 'rspec', cmd: 'bundle exec rspec --color --format progress' do
+  # watch /lib/ files
+  watch(%r{^lib/(.+).rb$}) do |m|
+    "spec/#{m[1]}_spec.rb"
+  end
+
+  # watch /spec/ files
+  watch(%r{^spec/(.+).rb$}) do |m|
+    "spec/#{m[1]}.rb"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 AMar4enko
+
+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,61 @@
+# Grape::Reload
+
+Expiremental approach for providing reloading of Grape-based rack applications in dev environment.  
+It uses Ripper to extract class usage and definitions from code and reloads files and API classes based on dependency map.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'grape-reload'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install grape-reload
+
+## Usage
+
+In your config.ru you use Grape::RackBuilder to mount your apps:
+
+    builder = Grape::RackBuilder.setup do
+        logger Logger.new(STDOUT)
+        add_source_path File.expand_path('**/*.rb', YOUR_APP_ROOT)
+        reload_threshold 1 # Reload sources not often one second
+        mount 'Your::App', to: '/'
+        mount 'Your::App1', to: '/app1'
+    end
+
+    run builder.boot!.application
+
+Grape::Reload will resolve all class dependencies and load your files in appropriate order, so you don't need to include 'require' or 'require_relative' for your app classes.
+
+## Restrictions:
+
+If you want to monkey-patch class in your code for any reason, you should use 
+    
+    AlreadyDefined.class_eval do 
+    end
+
+instead of
+
+    class AlreadyDefined
+    end  
+
+because it confuses dependency resolver
+
+## Known issues
+
+* It still lacks of good design :(  
+* MOAR TESTS!!!!111
+
+## Contributing
+
+1. Fork it ( https://github.com/AMar4enko/grape-reload/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'nested']
+end
+
+task :default => :spec

data/grape-reload.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'grape/reload/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "grape-reload"
+  spec.version       = Grape::Reload::VERSION
+  spec.authors       = ["AMar4enko"]
+  spec.email         = ["amar4enko@gmail.com"]
+  spec.summary       = 'Grape autoreload gem'
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "grape", "~> 0.9"
+  spec.add_runtime_dependency "rack", "~> 1.5.2"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rack-test"
+  spec.add_development_dependency "terminal-notifier-guard"
+  spec.add_development_dependency "rspec-nc"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-remote"
+  spec.add_development_dependency "pry-nav"
+end

data/lib/core_ext/object_space.rb

@@ -0,0 +1,49 @@
+module ObjectSpace
+  class << self
+    ##
+    # Returns all the classes in the object space.
+    # Optionally, a block can be passed, for example the following code
+    # would return the classes that start with the character "A":
+    #
+    #  ObjectSpace.classes do |klass|
+    #    if klass.to_s[0] == "A"
+    #      klass
+    #    end
+    #  end
+    #
+    def classes(&block)
+      rs = Set.new
+
+      ObjectSpace.each_object(Class).each do |klass|
+        if block
+          if r = block.call(klass)
+            # add the returned value if the block returns something
+            rs << r
+          end
+        else
+          rs << klass
+        end
+      end
+
+      rs
+    end
+
+    ##
+    # Returns a list of existing classes that are not included in "snapshot"
+    # This method is useful to get the list of new classes that were loaded
+    # after an event like requiring a file.
+    # Usage:
+    #
+    #   snapshot = ObjectSpace.classes
+    #   # require a file
+    #   ObjectSpace.new_classes(snapshot)
+    #
+    def new_classes(snapshot)
+      self.classes do |klass|
+        if !snapshot.include?(klass)
+          klass
+        end
+      end
+    end
+  end
+end

data/lib/grape/reload/dependency_map.rb

@@ -0,0 +1,130 @@
+require_relative '../../ripper/extract_constants'
+
+module Grape
+  module Reload
+    class DependencyMap
+      extend Forwardable
+      include TSort
+
+      attr_accessor :map
+
+      def tsort_each_child(node, &block)
+        @files_linked.fetch(node).each(&block)
+      end
+
+      def tsort_each_node(&block)
+        @files_linked.each_key(&block)
+      end
+
+      def initialize(sources)
+        @sources = sources
+        files = @sources.map{|p| Dir[p]}.flatten.uniq
+        @map = Hash[files.zip(files.map{|file| Ripper.extract_constants(File.read(file))})]
+      end
+
+      def sorted_files
+        tsort
+      end
+
+      def files
+        map.keys
+      end
+
+      def dependent_classes(loaded_file)
+        classes = []
+        cycle_classes = ->(file, visited_files = []){
+          return if visited_files.include?(file)
+          visited_files ||= []
+          visited_files << file
+          classes |= map[file][:declared] if file != loaded_file
+          map[file][:declared].map{|klass|
+            file_class = map.each_pair
+                .sort{|a1, a2|
+                  sorted.index(a1.first) - sorted.index(a2.first)
+                }
+                .select{|f, const_info| const_info[:used].include?(klass) }
+                .map{|k,v| [k,v[:declared]]}
+
+            file_class.each {|fc|
+              classes |= fc.last
+              cycle_classes.call(fc.first, visited_files)
+            }
+          }
+        }
+        cycle_classes.call(loaded_file)
+        classes
+      end
+
+      def fs_changes(&block)
+        result = {
+          added: [],
+          removed: [],
+          changed: []
+        }
+        files = @sources.map{|p| Dir[p]}.flatten.uniq
+        result[:added] = files - map.keys
+        result[:removed] = map.keys - files
+        result[:changed] = map.keys.select(&block)
+        result
+      end
+
+      def class_file(klass)
+        @file_class['::'+klass.to_s]
+      end
+
+      def files_reloading(&block)
+        yield
+        initialize(@sources)
+        resolve_dependencies!
+      end
+
+      def resolve_dependencies!
+        @file_class = Hash[map.each_pair.map{|file, hash|
+          hash[:declared].zip([file]*hash[:declared].size)
+        }.flatten(1)]
+        @files_linked = {}
+
+        unresolved_classes = {}
+        lib_classes = []
+        map.each_pair do |file, const_info|
+          @files_linked[file] ||= []
+          const_info[:used].each_with_index do |variants, idx|
+            next if lib_classes.include?(variants.last)
+            variant = variants.find{|v| @file_class[v]}
+            if variant.nil?
+              const_ref = variants.last
+              begin
+                const_ref.constantize
+                lib_classes << const_ref
+              rescue
+                unresolved_classes[const_ref] ||= []
+                unresolved_classes[const_ref] << file
+              end
+            else
+              @files_linked[file] << @file_class[variant] unless @files_linked[file].include?(@file_class[variant])
+              const_info[:used][idx] = variant
+            end
+          end
+        end
+
+        unresolved_classes.each_pair do |klass, filenames|
+          filenames.each {|filename| Grape::RackBuilder.logger.error("Unresolved const reference #{klass} from: #{filename}".colorize(:red)) }
+        end
+      end
+    end
+
+    class Sources
+      extend Forwardable
+      def_instance_delegators :'@dm', :sorted_files, :class_file, :fs_changes, :dependent_classes, :files_reloading
+      def initialize(sources)
+        @sources = sources
+        @dm = DependencyMap.new(sources)
+        @dm.resolve_dependencies!
+      end
+
+      def file_excluded?(file)
+        @sources.find{|path| File.fnmatch?(path, file) }.nil?
+      end
+    end
+  end
+end

data/lib/grape/reload/grape_api.rb

@@ -0,0 +1,89 @@
+require 'grape'
+
+module Grape
+  class ReloadMiddleware
+    class << self
+      def [](threshold)
+        threshold ||= 2
+        eval <<CLASS
+      Class.new(Grape::ReloadMiddleware) {
+        private
+        def reload_threshold
+          #{threshold > 0 ? threshold.to_s+".seconds" : "false" }
+        end
+      }
+CLASS
+      end
+    end
+
+    def initialize(app)
+      @app_klass = app.to_s
+    end
+
+    def call(*args)
+      if reload_threshold && (Time.now > (@last || reload_threshold.ago) + 1)
+        Thread.list.size > 1 ? Thread.exclusive { Grape::Reload::Watcher.reload! } : Grape::Reload::Watcher.reload!
+        @last = Time.now
+      else
+        Thread.list.size > 1 ? Thread.exclusive { Grape::Reload::Watcher.reload! } : Grape::Reload::Watcher.reload!
+      end
+      @app_klass.constantize.call(*args)
+    end
+    def reload_threshold; 2.seconds end
+  end
+end
+
+module Grape
+  module Reload
+    module AutoreloadInterceptor
+      [:set, :nest, :route, :imbue, :mount, :desc, :params, :helpers, :format, :formatter, :parser, :error_formatter, :content_type].each do |method|
+        eval <<METHOD
+        def #{method}(*args, &block)
+          class_declaration << [:#{method},args,block]
+          super(*args, &block)
+        end
+METHOD
+      end
+
+      def reinit!
+        declaration = class_declaration.dup
+        @class_decl = []
+        reset!
+        declaration.each {|decl|
+          send(decl[0],*deep_reconstantize.call(decl[1]),&decl[2])
+        }
+        change!
+      end
+    private
+      def class_declaration
+        @class_decl ||= []
+      end
+      def deep_reconstantize
+        proc = ->(value) {
+          case value
+            when Hash
+              Hash[value.each_pair.map { |k,v| [proc.call(k), proc.call(v)] }]
+            when Array
+              value.map { |v| proc.call(v) }
+            when Class
+              return if value.to_s[0,2] == '#<'
+              value.to_s.constantize
+            else
+              value
+          end
+        }
+      end
+    end
+  end
+end
+
+Grape::API.singleton_class.class_eval do
+  alias_method :inherited_shadowed, :inherited
+  alias_method :settings_shadowed, :settings
+  def inherited(*args)
+    inherited_shadowed(*args)
+    args.first.singleton_class.class_eval do
+      include Grape::Reload::AutoreloadInterceptor
+    end
+  end
+end

data/lib/grape/reload/rack_builder.rb

@@ -0,0 +1,108 @@
+require 'active_support/inflector'
+require_relative '../reload/watcher'
+require_relative '../reload/grape_api'
+require_relative '../reload/dependency_map'
+
+
+RACK_ENV = ENV["RACK_ENV"] ||= "development"  unless defined?(RACK_ENV)
+
+module Grape
+  module RackBuilder
+    module LoggingStub
+      class << self
+        [:error, :debug, :exception, :info, :devel].each do |level|
+          define_method(level){|*args|
+            puts level.to_s.upcase+": "+args.map{|a| a.to_s}.join(' ')+"\n"
+          }
+        end
+      end
+    end
+
+    class MountConfig
+      attr_accessor :app_class, :options, :mount_root
+      def initialize(options)
+        options.each_pair{|k,v| send(:"#{k}=", v) }
+      end
+    end
+
+    class Config
+      attr_accessor :mounts, :sources, :options
+
+      {environment: RACK_ENV, reload_threshold: 1, logger: LoggingStub}.each_pair do |attr, default|
+        attr_accessor attr
+        define_method(attr) { |value = nil|
+          @options ||= {}
+          @options[attr] = value if value
+          @options[attr] || default
+        }
+      end
+
+      def add_source_path(glob)
+        (@sources ||= []) << glob
+      end
+
+      def mount(app_class, options)
+        mounts << MountConfig.new(
+            app_class: app_class,
+            mount_root: options.delete(:to) || '/',
+            options: options
+        )
+      end
+
+      def mounts
+        @mounts ||= []
+      end
+    end
+
+    module ClassMethods
+      def setup(&block)
+        config.instance_eval(&block)
+        self
+      end
+
+      def boot!
+        Grape::Reload::Watcher.setup(sources: Grape::Reload::Sources.new(config.sources))
+        self
+      end
+
+      def application
+        return @rack_app if @rack_app
+        mounts = config.mounts
+        environment = config.environment
+        reload_threshold = config.reload_threshold
+        @rack_app = ::Rack::Builder.new do
+          mounts.each_with_index do |m|
+            if environment == 'development'
+              r = Rack::Builder.new
+              r.use Grape::ReloadMiddleware[reload_threshold]
+              r.run m.app_class.constantize
+              map(m.mount_root) { run r }
+            else
+              map(m.mount_root) { run m.app_class.constantize }
+            end
+          end
+        end
+      end
+
+      def mounted_apps_of(file)
+        config.mounts.select { |mount| File.identical?(file, Grape::Reloader.root(mount.app_file)) }
+      end
+
+      def reloadable_apps
+        config.mounts
+      end
+
+      def logger
+        config.logger
+      end
+
+      private
+      def config
+        @config ||= Config.new
+      end
+    end
+    class << self
+      include Grape::RackBuilder::ClassMethods
+    end
+  end
+end

data/lib/grape/reload/storage.rb

@@ -0,0 +1,57 @@
+require_relative '../../../lib/core_ext/object_space'
+
+module Grape
+  module Reload
+    module Storage
+      class << self
+        def clear!
+          files.each_key do |file|
+            remove(file)
+            Watcher.remove_feature(file)
+          end
+          @files = {}
+        end
+
+        def remove(name)
+          file = files[name] || return
+          file[:constants].each{ |constant| Watcher.remove_constant(constant) }
+          file[:features].each{ |feature| Watcher.remove_feature(feature) }
+          files.delete(name)
+        end
+
+        def prepare(name)
+          file = remove(name)
+          @old_entries ||= {}
+          @old_entries[name] = {
+              :constants => ObjectSpace.classes,
+              :features  => old_features = Set.new($LOADED_FEATURES.dup)
+          }
+          features = file && file[:features] || []
+          features.each{ |feature| Watcher.safe_load(feature, :force => true) unless Watcher.feature_excluded?(feature)}
+          Watcher.remove_feature(name) if old_features.include?(name)
+        end
+
+        def commit(name)
+          entry = {
+              :constants => ObjectSpace.new_classes(@old_entries[name][:constants]),
+              :features  => Set.new($LOADED_FEATURES) - @old_entries[name][:features] - [name]
+          }
+          files[name] = entry
+          @old_entries.delete(name)
+        end
+
+        def rollback(name)
+          new_constants = ObjectSpace.new_classes(@old_entries[name][:constants])
+          new_constants.each{ |klass| Watcher.remove_constant(klass) }
+          @old_entries.delete(name)
+        end
+
+        private
+
+        def files
+          @files ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/grape/reload/version.rb

@@ -0,0 +1,5 @@
+module Grape
+  module Reload
+    VERSION = "0.0.2"
+  end
+end