sinarey 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 52320fa050cf68249ee686d1d8a0e08ac28f1905
-  data.tar.gz: 66a2858bbde53da9b3b81137cf026575d7d073fe
+  metadata.gz: 1bee69a3761ccb406bdee2cedbd1cb81d851ceaa
+  data.tar.gz: f373640196f44cda768dad4b88d29ae9a02a5a81
 SHA512:
-  metadata.gz: b29e990f9e64c1fce9b008ab756f8f6cca957e338e3c78e8b9017f1ec7a6ff171e01ddf15a0c7443ff8eae100e32df4474ad4f6c481f6b52fc04e7045ba40b59
-  data.tar.gz: b16ba1a755d2b37232017eb21b5cf3425605e4798a81bf602acc4061b0980b83f6764179ce5f46043a84dc68e97444e02ade5e2a4671d5e3c8e3806fc0c47b90
+  metadata.gz: 17f7ab80712fa2253221f0e5c864ec9ca3fcb75105497db34d75ee21fece68adb8105d15c834e22e17b12b99a3d1717e165bc2dfba509a15cddfb6f2d1d4ab8f
+  data.tar.gz: e8547832624b5abcc05935cf6a8b9ba32588b5397ab063f16a6fe01cfeff1fe008ceb87440f088a99e66b5a13eae8fce76c0de2c0f34215db31278f391b3f044

data/lib/sinarey/router.rb

@@ -58,23 +58,62 @@ module Sinarey
       end
     end
 
-    def apps_route(verb, path, env)
-      if turbo_route = (turbo_routes = @turbo_routes[verb]) && turbo_routes[path]
-        turbo_route.tap do |block_id,app_id|
-          env['sinarey.router'] = {type: :turbo, block_id: block_id}
-          status, headers, response = @apps[app_id].call(env)
-          return status, headers, response
+    case ENV["RACK_ENV"]
+    when 'development'
+      
+      #development need support sinarey reloader.so here use dev logic.
+      def apps_route(verb, path, env)
+
+        #auto reload modified code
+        @apps.each do |index,app|
+          app.auto_reload if app.respond_to?(:auto_reload)
+        end
+
+        #rebuild route table
+        @turbo_routes = {}
+        @routes       = {}
+        build_routing_table
+
+        if turbo_route = (turbo_routes = @turbo_routes[verb]) && turbo_routes[path]
+          turbo_route.tap do |block_id,app_id|
+            env['sinarey.router'] = {type: :turbo, block_id: block_id}
+            status, headers, response = @apps[app_id].call(env)
+            return status, headers, response
+          end
+        elsif routes = @routes[verb]
+          routes.each do |pattern, keys, conditions, block_id, app_id|
+            if match = pattern.match(path)
+              env['sinarey.router'] = {type: :normal, match: match, keys: keys, conditions: conditions, block_id: block_id}
+              status, headers, response = @apps[app_id].call(env)
+              return status, headers, response
+            end
+          end
         end
-      elsif routes = @routes[verb]
-        routes.each do |pattern, keys, conditions, block_id, app_id|
-          if match = pattern.match(path)
-            env['sinarey.router'] = {type: :normal, match: match, keys: keys, conditions: conditions, block_id: block_id}
+        nil
+      end
+
+    else
+
+      def apps_route(verb, path, env)
+        if turbo_route = (turbo_routes = @turbo_routes[verb]) && turbo_routes[path]
+          turbo_route.tap do |block_id,app_id|
+            env['sinarey.router'] = {type: :turbo, block_id: block_id}
             status, headers, response = @apps[app_id].call(env)
             return status, headers, response
           end
+        elsif routes = @routes[verb]
+          routes.each do |pattern, keys, conditions, block_id, app_id|
+            if match = pattern.match(path)
+              env['sinarey.router'] = {type: :normal, match: match, keys: keys, conditions: conditions, block_id: block_id}
+              status, headers, response = @apps[app_id].call(env)
+              return status, headers, response
+            end
+          end
         end
+        nil
       end
-      nil
+
     end
+
   end
 end

data/lib/sinarey/version.rb

@@ -1,3 +1,3 @@
 module Sinarey
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

data/lib/sinatra/sinarey_reloader.rb

@@ -0,0 +1,254 @@
+require 'sinatra/base'
+
+module Sinatra
+
+  module SinareyReloader
+
+    class Watcher
+
+      class Element < Struct.new(:type, :representation)
+      end
+
+      class List
+        @app_list_map = Hash.new { |hash, key| hash[key] = new }
+
+        def self.for(app)
+          @app_list_map[app]
+        end
+
+        def initialize
+          @path_watcher_map = Hash.new do |hash, key|
+            hash[key] = Watcher.new(key)
+          end
+        end
+
+        def watch(path, element)
+          watcher_for(path).elements << element
+        end
+
+        def ignore(path)
+          watcher_for(path).ignore
+        end
+
+        def watcher_for(path)
+          @path_watcher_map[File.expand_path(path)]
+        end
+        alias watch_file watcher_for
+
+        def watchers
+          @path_watcher_map.values
+        end
+
+        def updated
+          watchers.find_all(&:updated?)
+        end
+      end
+
+      attr_reader :path, :elements, :mtime
+
+      def initialize(path)
+        @path, @elements = path, []
+        update
+      end
+
+      def updated?
+        !ignore? && !removed? && mtime != File.mtime(path)
+      end
+
+      def update
+        @mtime = File.mtime(path)
+      end
+
+      def inline_templates?
+        elements.any? { |element| element.type == :inline_templates }
+      end
+
+      def ignore
+        @ignore = true
+      end
+
+      def ignore?
+        !!@ignore
+      end
+
+      def removed?
+        !File.exist?(path)
+      end
+    end
+
+    def self.registered(klass)
+      @reloader_loaded_in ||= {}
+      return if @reloader_loaded_in[klass]
+
+      @reloader_loaded_in[klass] = true
+
+      klass.extend BaseMethods
+      klass.extend ExtensionMethods
+      klass.set(:reload_templates) { true }
+
+      def klass.auto_reload
+        SinareyReloader.perform(settings)
+      end
+
+      klass.before do
+        SinareyReloader.perform(klass)
+      end
+      klass.set(:inline_templates, klass.app_file) if klass == Sinatra::Application
+    end
+
+    def self.perform(klass)
+      updated_sum = 0
+      Watcher::List.for(klass).updated.each do |watcher|
+        updated_sum += 1
+        klass.set(:inline_templates, watcher.path) if watcher.inline_templates?
+        watcher.elements.each { |element|
+          klass.deactivate(element) 
+        }
+        $LOADED_FEATURES.delete(watcher.path)
+        require watcher.path
+        watcher.update
+      end
+      return updated_sum
+    end
+
+    def self.thread_safe?
+      Thread and Thread.list.size > 1 and Thread.respond_to?(:exclusive)
+    end
+
+    module BaseMethods
+      def run!(*args)
+        if settings.reloader?
+          super unless running?
+        else
+          super
+        end
+      end
+
+      def compile!(verb, path, block, options = {})
+        source_location = block.respond_to?(:source_location) ?
+          block.source_location.first : caller_files[1]
+        signature = super
+        watch_element(
+          source_location, :route, { :verb => verb, :signature => signature }
+        )
+        signature
+      end
+
+      def turbo_compile!(verb, path, block, options = {})
+        source_location = block.respond_to?(:source_location) ?
+          block.source_location.first : caller_files[1]
+        signature = super
+        watch_element(
+          source_location, :turbo_route, { :verb => verb, :path => path, :block_id => signature }
+        )
+        signature
+      end
+
+      def inline_templates=(file=nil)
+        file = (file.nil? || file == true) ?
+          (caller_files[1] || File.expand_path($0)) : file
+        watch_element(file, :inline_templates)
+        super
+      end
+
+      def use(middleware, *args, &block)
+        path = caller_files[1] || File.expand_path($0)
+        watch_element(path, :middleware, [middleware, args, block])
+        super
+      end
+
+      def add_filter(type, path = nil, options = {}, &block)
+        source_location = block.respond_to?(:source_location) ?
+          block.source_location.first : caller_files[1]
+        result = super
+        watch_element(source_location, :"#{type}_filter", filters[type].last)
+        result
+      end
+
+      def error(*codes, &block)
+        path = caller_files[1] || File.expand_path($0)
+        result = super
+        codes.each do |c|
+          watch_element(path, :error, :code => c, :handler => @errors[c])
+        end
+        result
+      end
+
+      def register(*extensions, &block)
+        start_registering_extension
+        result = super
+        stop_registering_extension
+        result
+      end
+
+      def inherited(subclass)
+        result = super
+        subclass.register Sinatra::SinareyReloader
+        result
+      end
+    end
+
+    module ExtensionMethods
+      def deactivate(element)
+        case element.type
+        when :route then
+          verb      = element.representation[:verb]
+          signature = element.representation[:signature]
+          block_id  = signature.last
+          (blocks ||= {}).delete(block_id)
+          (routes[verb] ||= []).delete(signature)
+        when :turbo_route then
+          verb      = element.representation[:verb]
+          path      = element.representation[:path]
+          block_id  = element.representation[:block_id]
+          (blocks ||= {}).delete(block_id)
+          (turbo_routes[verb] ||= {}).delete(path)
+        when :middleware then
+          @middleware.delete(element.representation)
+        when :before_filter then
+          filters[:before].delete(element.representation)
+        when :after_filter then
+          filters[:after].delete(element.representation)
+        when :error then
+          code    = element.representation[:code]
+          handler = element.representation[:handler]
+          @errors.delete(code) if @errors[code] == handler
+        end
+      end
+
+      def also_reload(*glob)
+        Dir[*glob].each { |path| Watcher::List.for(self).watch_file(path) }
+      end
+
+      def dont_reload(*glob)
+        Dir[*glob].each { |path| Watcher::List.for(self).ignore(path) }
+      end
+
+    private
+
+      attr_reader :register_path
+
+      def start_registering_extension
+        @register_path = caller_files[2]
+      end
+
+      def stop_registering_extension
+        @register_path = nil
+      end
+
+      def registering_extension?
+        !register_path.nil?
+      end
+
+      def watch_element(path, type, representation=nil)
+        list = Watcher::List.for(self)
+        element = Watcher::Element.new(type, representation)
+        list.watch(path, element)
+        list.watch(register_path, element) if registering_extension?
+      end
+    end
+  end
+
+  register SinareyReloader
+  Delegator.delegate :also_reload, :dont_reload
+end

data/sinarey.gemspec

@@ -10,7 +10,8 @@ Gem::Specification.new 'sinarey',Sinarey::VERSION do |spec|
   spec.homepage      = "https://github.com/maymay25/sinarey"
   spec.license       = "MIT"
 
-  spec.files         = ['lib/sinarey/version.rb',
+  spec.files         = ['lib/sinatra/sinarey_reloader.rb',
+                        'lib/sinarey/version.rb',
                         'lib/sinarey/base.rb',
                         'lib/sinarey/router.rb',
                         'lib/sinarey.rb',

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sinarey
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Jeffrey
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-21 00:00:00.000000000 Z
+date: 2014-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -31,6 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/sinatra/sinarey_reloader.rb
 - lib/sinarey/version.rb
 - lib/sinarey/base.rb
 - lib/sinarey/router.rb