code_sync 0.6.7

data/lib/code_sync/processors.rb

@@ -0,0 +1,18 @@
+require "code_sync/processors/jst_processor"
+
+module CodeSync
+  module Processors
+    Map = {
+      ".jst.skim" => CodeSync::Processors::JstProcessor
+    }
+  end
+
+  def self.lookup_processor_for_extension(extension)
+    if processor = Processors::Map[extension]
+      processor
+    else
+      CodeSync::Processors::Basic
+    end
+  end
+
+end

data/lib/code_sync/processors/basic.rb

@@ -0,0 +1,9 @@
+module CodeSync
+  module Processors
+    class Basic
+      def self.process(contents)
+        contents
+      end
+    end
+  end
+end

data/lib/code_sync/processors/jst_processor.rb

@@ -0,0 +1,17 @@
+require 'pry'
+
+module CodeSync
+  module Processors
+    class JstProcessor
+      def self.process contents,filename="adhoc",extension=".jst"
+        contents.match(/this.JST\[(.*)\]/) do |match|
+          if match[1]
+            contents[match[1]] = "\"#{filename}\""
+          end
+        end
+
+        contents
+      end
+    end
+  end
+end

data/lib/code_sync/pry_console.rb

@@ -0,0 +1,132 @@
+require 'multi_json'
+require 'pry'
+
+puts "Defining Pry Session Server"
+
+# Thanks to the rack-webconsole-pry project
+# for showing me the way to handle this
+module CodeSync
+  class PrySessionServer
+    def initialize(app, options={})
+      @app = app
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+      params  = request.params
+
+      return @app.call(env) unless request.post? && (authenticate(params,env) && params['code'])
+
+      process(params['code'])
+    end
+
+    protected
+
+      def process(code)
+        response = {}
+
+        if $pry.nil?
+          Pry.pager = false
+          $pry_output         = StringIO.new("")
+          $pry_output.string  = ""
+          $pry                = Pry.new(output: $pry_output, pager: false)
+          Pry.initial_session_setup
+        end
+
+        pry = $pry
+
+        puts "hi"
+        binding.pry
+
+        # repl loop
+        if pry.binding_stack.last
+          target = Pry.binding_for(pry.binding_stack.last)
+        else
+          target = Pry.binding_for(TOPLEVEL_BINDING)
+        end
+
+        pry.repl_prologue(target) unless pry.binding_stack.last == target
+        pry.inject_sticky_locals(target)
+
+        response[:prompt] = pry.select_prompt("", target) + Pry::Code.new(code).to_s
+
+        received_output = false
+
+        begin
+
+          read_pipe, write_pipe = IO.pipe
+          end_line              = "~~~~pry-console output end~~~~"
+
+          puts "getting to the thread"
+
+          thread = Thread.new do
+            while true
+              new_line = read_pipe.readline
+              break if new_line == end_line
+              $pry_output << new_line
+            end
+          end
+
+          old_stdout = STDOUT.dup
+          old_stderr = STDERR.dup
+
+          STDOUT.reopen(write_pipe)
+          STDERR.reopen(write_pipe)
+
+          if !pry.process_command(code, "", target)
+            result = target.send(:eval, code, Pry.eval_path, Pry.current_line)
+            received_output = true
+          end
+
+          if received_output
+            pry.set_last_result(result, target, code)
+            Pry.print.call($pry_output, result) if pry.should_print?
+          end
+
+          $pry_output.write(error_out) if error_out
+
+          response[:result] = $pry_output.string
+
+          respond_with(response)
+
+        rescue StandardError => e
+          error_out = "Error: " + e.message
+
+        ensure
+          write_pipe << end_line
+
+          thr.join
+          read_pipe.close
+          write_pipe.close
+          STDOUT.reopen(old_stdout)
+          STDERR.reopen(old_stderr)
+
+          puts "Enrusre"
+        end
+
+      end
+
+
+      # Outputs a hash that has a
+      #   - prompt
+      #   - result
+      #
+      def respond_with(hash)
+        response_body = MultiJson.encode(hash)
+
+        headers = {
+          "Content-Type" => "application/json",
+          "Content-Length" => response_body.bytesize.to_s
+        }
+      end
+
+
+      def authenticate(params, env)
+        true
+      end
+
+      def setup_pry_process
+
+      end
+  end
+end

data/lib/code_sync/rails.rb

@@ -0,0 +1,7 @@
+require "code_sync/rails/engine"
+
+module CodeSync
+  module Rails
+    VERSION = CodeSync::Version
+  end
+end

data/lib/code_sync/rails/engine.rb

@@ -0,0 +1,12 @@
+module CodeSync
+  class Engine < ::Rails::Engine
+    initializer 'code_sync.manager', :before => :build_middleware_stack do |app|
+      enabled = (app.config.enable_code_sync_manager == true) rescue false
+      forbid_saving = (app.config.forbid_code_sync_save) rescue false
+
+      if enabled && !$rails_rake_task
+        CodeSync::Manager.start(sprockets: app.assets, forked: true, forbid_saving: !!forbid_saving)
+      end
+    end
+  end
+end

data/lib/code_sync/server.rb

@@ -0,0 +1,225 @@
+require 'thin'
+require 'faye'
+require 'rack'
+require 'json'
+require 'pry'
+
+require "code_sync/temp_asset"
+require "code_sync/sprockets_adapter"
+require "code_sync/pry_console"
+
+module CodeSync
+  class Server
+    attr_accessor :assets,
+                  :faye,
+                  :root,
+                  :options,
+                  :forbid_saving,
+                  :rack
+
+
+    def initialize options={}
+      @options        = options.dup
+      @assets         = options[:assets] || CodeSync::SprocketsAdapter.new(root:Dir.pwd())
+      @root           = options[:root]
+      @forbid_saving  = !!(options[:forbid_saving])
+
+      Faye::WebSocket.load_adapter('thin')
+
+      @faye   = Faye::RackAdapter.new(mount:"/faye",timeout:25)
+
+      faye.add_extension(FayeMonitor.new)
+    end
+
+    def call(env)
+      [200, {"Access-Control-Allow-Origin"=>"*","Content-Type" => "application/json"}, [{code_sync:true}.to_json]]
+    end
+
+    def allow_saving?
+      forbid_saving == true
+    end
+
+    def urlmap
+      Rack::URLMap.new   "/assets" =>   assets.env,
+                         "/" =>         faye,
+                         "/info" =>     ServerInfo.new(self, sprockets:assets, options: options, root: root, allow_saving: allow_saving?),
+                         "/source" =>   SourceProvider.new(self, sprockets:assets, allow_saving: allow_saving?)
+    end
+
+    def start port=9295
+      @port = port
+      Rack::Server.start(app:urlmap,:Port=>port,:server=>'thin',:pid => File.join("/tmp/codesync-server.pid") )
+    end
+
+    def stop
+
+    end
+
+    class FayeMonitor
+      def incoming(message,callback)
+        if message['channel'] == "/meta/subscribe" and message['subscription']
+        end
+
+        callback.call(message)
+      end
+    end
+
+    class SourceProvider
+      attr_accessor :sprockets, :root, :options
+
+      def initialize app, options={}
+        @options = options
+        @sprockets = options[:sprockets]
+        @root = options[:root] || Dir.pwd()
+      end
+
+      def to_s
+        "codesync source gateway"
+      end
+
+      def allow_saving?
+        options[:allow_saving] == true
+      end
+
+      def handle_file_write(params={}, response)
+        path, contents = params.values_at "path", "contents"
+
+        unless path.match(/^\//)
+          path = File.join(root,path)
+        end
+
+        begin
+          raise 'Saving is disabled' unless allow_saving?
+
+          if File.exists?(path)
+            File.open(path,"w+") {|fh| fh.puts(contents)}
+          else
+            response[:success] = false
+            response[:error] = "File not found: #{ path } :: #{ $! }"
+          end
+        rescue
+          response[:error] = "#{ $! }"
+          response[:success] = false
+        end
+      end
+
+      def handle_adhoc_compilation(params={}, response={})
+        contents, filename, extension = params.values_at("contents", "name", "extension")
+
+        begin
+          asset = TempAsset.create_from(contents, env: sprockets, filename: filename, extension: extension)
+          response[:contents] = contents
+          response[:compiled] = process_compiled_asset(asset.to_s,filename,extension)
+        rescue
+          response[:error] = $!
+          response[:success] = false
+        end
+
+        response
+      end
+
+      def process_compiled_asset contents, filename, extension
+        begin
+          processor = CodeSync.lookup_processor_for_extension(extension)
+          processor.process(contents,filename,extension)
+        rescue
+          contents
+        end
+      end
+
+      def handle_post(env)
+        response = {success: true}
+
+        env['rack.input'].rewind
+        body = env['rack.input'].read
+
+        params = begin
+         JSON.parse(body)
+        rescue
+          response[:success] = false
+          response[:error] = $!
+          response[:body] = body
+          return response
+        end
+
+        if params["path"] && params["contents"] && params["path"].length > 0
+          handle_file_write(params, response)
+          return response
+        end
+
+        if params["name"] && params["extension"] && params["contents"]
+          handle_adhoc_compilation(params, response)
+          return response
+        end
+
+        response
+      end
+
+      def handle_get(env)
+        response = {success: true}
+
+        query = Rack::Utils.parse_query env['QUERY_STRING']
+
+        if query['path']
+          response.merge! success: true, contents: IO.read(query["path"])
+        else
+          response.merge! success: false, error: "Must specify an asset path"
+        end
+
+        response
+      end
+
+      # Why am I not just using Sinatra here?
+      def call(env)
+        response = begin
+          if env['REQUEST_METHOD'] == "POST"
+            handle_post(env)
+          else
+            handle_get(env)
+          end
+        rescue
+          response[:success] = false
+          response[:error] = "Fatal Error: #{ $! }"
+        end
+
+        if response[:success]
+          [200, {"Access-Control-Allow-Origin"=>"*","Content-Type" => "application/json"}, [JSON.generate(response)] ]
+        else
+          [200, {"Access-Control-Allow-Origin"=>"*","Content-Type" => "application/json"}, [JSON.generate(response)] ]
+        end
+      end
+    end
+
+    class ServerInfo
+      attr_accessor :faye, :sprockets, :options
+
+      def initialize app, options={}
+        @sprockets  = options[:sprockets]
+        @faye       = options[:faye]
+        @options    = options.dup
+      end
+
+      def to_s
+        "codesync server info"
+      end
+
+      def allow_saving?
+        options[:allow_saving] == true
+      end
+
+      def call(env)
+        response = JSON.generate(project_assets: sprockets.project_assets, codesync_version: CodeSync::Version,paths:sprockets.env.paths, root:@options[:root], allow_saving: allow_saving?)
+        [200, {"Access-Control-Allow-Origin"=>"*","Content-Type" => "application/json"}, [response]]
+      end
+    end
+  end
+end
+
+  #   Thin::Server.start('0.0.0.0', 3000) do
+  #     use Rack::CommonLogger
+  #     use Rack::ShowExceptions
+  #     map "/lobster" do
+  #       use Rack::Lint
+  #       run Rack::Lobster.new
+  #     end
+  #   end

data/lib/code_sync/sprockets_adapter.rb

@@ -0,0 +1,145 @@
+module CodeSync
+  class AssetPipelineGems
+    TestPaths = %w{
+      assets/stylesheets
+      assets/javascripts
+      assets/images
+      app/assets/javascripts
+      lib/assets/javascripts
+      vendor/assets/javascripts
+      app/assets/stylesheets
+      lib/assets/stylesheets
+      vendor/assets/stylesheets
+      app/assets/images
+      lib/assets/images
+      vendor/assets/images
+      javascripts
+      stylesheets
+      images
+    }
+
+    def self.gems
+      begin
+        return @gems if !@gems.nil?
+
+        gems = ::Gem::Specification.latest_specs
+
+        gems.select! do |gemspec|
+          base = gemspec.full_gem_path
+          TestPaths.detect {|folder| File.exists?(File.join(base,folder))}
+        end
+      rescue
+        []
+      end
+    end
+
+    def self.paths
+      paths = gems.flat_map do |gemspec|
+        base = gemspec.full_gem_path
+        TestPaths.map {|folder| File.join(base, folder)}
+      end
+
+      paths.select {|dir| File.exists?(dir) }
+    end
+  end
+
+  class SprocketsAdapter
+    attr_accessor :env, :options
+
+    def initialize sprockets, options=nil
+      if options.nil? and sprockets.is_a?(Hash)
+        options = sprockets
+        sprockets = nil
+      end
+
+      @options = options
+
+      @env = options[:sprockets] || Sprockets::Environment.new(options[:root] ||= Dir.pwd())
+
+      append_asset_paths()
+    end
+
+    def process_changes_to assets=[]
+
+      results = Array(assets).map do |path|
+
+        asset = env.find_asset(path)
+
+        asset && notification = {
+          asset_path: path,
+          digest_path:asset.digest_path,
+          name:asset.logical_path,
+          source: (asset.to_s rescue nil),
+          path: path,
+          content: IO.read(path)
+        }
+      end
+
+      Array(results)
+    end
+
+    def compile content, options={}
+      create_asset(content,options).to_s
+    end
+
+    def create_asset content, options={}
+      TempAsset.create_from(content, options.merge(env: env))
+    end
+
+    def project_asset_directories
+      directories = env.paths.select {|path| path.include?(root) }
+    end
+
+    def project_assets
+      files = project_asset_directories.inject([]) do |memo, path|
+        memo += Dir.glob("#{path}/**/*")
+      end
+
+      files.reject! {|path| path.match(/\.min\.js/) || path.match(/\-min\.js/) }
+      files.select! {|path| path.match(/\.jst|\.coffee|\.css|\.js/)}
+
+      files
+    end
+
+
+    def method_missing meth, *args, &block
+      env.send(meth, *args, &block)
+    end
+
+    protected
+
+      def tmpdir
+        @tmpdir ||= Dir.tmpdir
+      end
+
+      def append_gem_paths
+        AssetPipelineGems.paths.each {|path| env.append_path(path) }
+      end
+
+      def append_temporary_path
+        env.prepend_path(tmpdir)
+      end
+
+      def append_asset_paths base_path=nil
+        base_path ||= env.root
+
+        append_gem_paths
+
+        env.append_path tmpdir
+
+        env.append_path CodeSync.gem_assets_root
+
+        %w{lib vendor app}.each do |base|
+          path = File.join(env.root, base, 'assets')
+
+          if File.exists?(path)
+            %w{images stylesheets javascripts}.each do |type|
+              if File.exists?(File.join(path, type))
+                env.append_path(File.join(path, type))
+              end
+            end
+          end
+        end
+      end
+  end
+end