code_sync 0.6.7

data/lib/assets/stylesheets/vendor/vendored_codemirror.css

@@ -0,0 +1,246 @@
+/* BASICS */
+
+.CodeMirror {
+  /* Set height, width, borders, and global font properties here */
+  font-family: monospace;
+  height: 300px;
+}
+.CodeMirror-scroll {
+  /* Set scrolling behaviour here */
+  overflow: auto;
+}
+
+/* PADDING */
+
+.CodeMirror-lines {
+  padding: 4px 0; /* Vertical padding around content */
+}
+.CodeMirror pre {
+  padding: 0 4px; /* Horizontal padding of content */
+}
+
+.CodeMirror-scrollbar-filler {
+  background-color: white; /* The little square between H and V scrollbars */
+}
+
+/* GUTTER */
+
+.CodeMirror-gutters {
+  border-right: 1px solid #ddd;
+  background-color: #f7f7f7;
+}
+.CodeMirror-linenumbers {}
+.CodeMirror-linenumber {
+  padding: 0 3px 0 5px;
+  min-width: 20px;
+  text-align: right;
+  color: #999;
+}
+
+/* CURSOR */
+
+.CodeMirror div.CodeMirror-cursor {
+  border-left: 1px solid black;
+  z-index: 3;
+}
+/* Shown when moving in bi-directional text */
+.CodeMirror div.CodeMirror-secondarycursor {
+  border-left: 1px solid silver;
+}
+.CodeMirror.cm-keymap-fat-cursor div.CodeMirror-cursor {
+  width: auto;
+  border: 0;
+  background: #7e7;
+  z-index: 1;
+}
+/* Can style cursor different in overwrite (non-insert) mode */
+.CodeMirror div.CodeMirror-cursor.CodeMirror-overwrite {}
+
+.cm-tab { display: inline-block; }
+
+/* DEFAULT THEME */
+
+.cm-s-default .cm-keyword {color: #708;}
+.cm-s-default .cm-atom {color: #219;}
+.cm-s-default .cm-number {color: #164;}
+.cm-s-default .cm-def {color: #00f;}
+.cm-s-default .cm-variable {color: black;}
+.cm-s-default .cm-variable-2 {color: #05a;}
+.cm-s-default .cm-variable-3 {color: #085;}
+.cm-s-default .cm-property {color: black;}
+.cm-s-default .cm-operator {color: black;}
+.cm-s-default .cm-comment {color: #a50;}
+.cm-s-default .cm-string {color: #a11;}
+.cm-s-default .cm-string-2 {color: #f50;}
+.cm-s-default .cm-meta {color: #555;}
+.cm-s-default .cm-error {color: #f00;}
+.cm-s-default .cm-qualifier {color: #555;}
+.cm-s-default .cm-builtin {color: #30a;}
+.cm-s-default .cm-bracket {color: #997;}
+.cm-s-default .cm-tag {color: #170;}
+.cm-s-default .cm-attribute {color: #00c;}
+.cm-s-default .cm-header {color: blue;}
+.cm-s-default .cm-quote {color: #090;}
+.cm-s-default .cm-hr {color: #999;}
+.cm-s-default .cm-link {color: #00c;}
+
+.cm-negative {color: #d44;}
+.cm-positive {color: #292;}
+.cm-header, .cm-strong {font-weight: bold;}
+.cm-em {font-style: italic;}
+.cm-link {text-decoration: underline;}
+
+.cm-invalidchar {color: #f00;}
+
+div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
+div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
+
+/* STOP */
+
+/* The rest of this file contains styles related to the mechanics of
+   the editor. You probably shouldn't touch them. */
+
+.CodeMirror {
+  line-height: 1;
+  position: relative;
+  overflow: hidden;
+  background: white;
+  color: black;
+}
+
+.CodeMirror-scroll {
+  /* 30px is the magic margin used to hide the element's real scrollbars */
+  /* See overflow: hidden in .CodeMirror */
+  margin-bottom: -30px; margin-right: -30px;
+  padding-bottom: 30px; padding-right: 30px;
+  height: 100%;
+  outline: none; /* Prevent dragging from highlighting the element */
+  position: relative;
+}
+.CodeMirror-sizer {
+  position: relative;
+}
+
+/* The fake, visible scrollbars. Used to force redraw during scrolling
+   before actuall scrolling happens, thus preventing shaking and
+   flickering artifacts. */
+.CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler {
+  position: absolute;
+  z-index: 6;
+  display: none;
+}
+.CodeMirror-vscrollbar {
+  right: 0; top: 0;
+  overflow-x: hidden;
+  overflow-y: scroll;
+}
+.CodeMirror-hscrollbar {
+  bottom: 0; left: 0;
+  overflow-y: hidden;
+  overflow-x: scroll;
+}
+.CodeMirror-scrollbar-filler {
+  right: 0; bottom: 0;
+  z-index: 6;
+}
+
+.CodeMirror-gutters {
+  position: absolute; left: 0; top: 0;
+  height: 100%;
+  padding-bottom: 30px;
+  z-index: 3;
+}
+.CodeMirror-gutter {
+  height: 100%;
+  padding-bottom: 30px;
+  margin-bottom: -32px;
+  display: inline-block;
+  /* Hack to make IE7 behave */
+  *zoom:1;
+  *display:inline;
+}
+.CodeMirror-gutter-elt {
+  position: absolute;
+  cursor: default;
+  z-index: 4;
+}
+
+.CodeMirror-lines {
+  cursor: text;
+}
+.CodeMirror pre {
+  /* Reset some styles that the rest of the page might have set */
+  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
+  border-width: 0;
+  background: transparent;
+  font-family: inherit;
+  font-size: inherit;
+  margin: 0;
+  white-space: pre;
+  word-wrap: normal;
+  line-height: inherit;
+  color: inherit;
+  z-index: 2;
+  position: relative;
+  overflow: visible;
+}
+.CodeMirror-wrap pre {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  word-break: normal;
+}
+.CodeMirror-linebackground {
+  position: absolute;
+  left: 0; right: 0; top: 0; bottom: 0;
+  z-index: 0;
+}
+
+.CodeMirror-linewidget {
+  position: relative;
+  z-index: 2;
+  overflow: auto;
+}
+
+.CodeMirror-widget {
+  display: inline-block;
+}
+
+.CodeMirror-wrap .CodeMirror-scroll {
+  overflow-x: hidden;
+}
+
+.CodeMirror-measure {
+  position: absolute;
+  width: 100%; height: 0px;
+  overflow: hidden;
+  visibility: hidden;
+}
+.CodeMirror-measure pre { position: static; }
+
+.CodeMirror div.CodeMirror-cursor {
+  position: absolute;
+  visibility: hidden;
+  border-right: none;
+  width: 0;
+}
+.CodeMirror-focused div.CodeMirror-cursor {
+  visibility: visible;
+}
+
+.CodeMirror-selected { background: #d9d9d9; }
+.CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
+
+.cm-searching {
+  background: #ffa;
+  background: rgba(255, 255, 0, .4);
+}
+
+/* IE7 hack to prevent it from returning funny offsetTops on the spans */
+.CodeMirror span { *vertical-align: text-bottom; }
+
+@media print {
+  /* Hide the cursor when printing */
+  .CodeMirror div.CodeMirror-cursor {
+    visibility: hidden;
+  }
+}

data/lib/code_sync.rb

@@ -0,0 +1,41 @@
+$:.unshift File.dirname(__FILE__)
+
+module CodeSync
+  require 'code_sync/version'
+  require 'code_sync/manager'
+  require 'code_sync/processors'
+
+  if defined?(Middleman)
+    require 'middleman_extension'
+  end
+
+  if defined?(::Rails)
+    require "code_sync/rails"
+  end
+
+  def self.gem_assets_root
+    File.join(File.dirname(__FILE__), '..')
+  end
+
+end
+
+# When using outside of Rails.
+# Allows for using Rails asset pipline gems.
+unless defined? ::Rails
+  module Rails
+    def self.version
+      "3.2.13"
+    end
+
+    def self.env
+      Class.new do
+        def test?
+          false
+        end
+      end.new
+    end
+
+    class Engine
+    end
+  end
+end

data/lib/code_sync/cli.rb

@@ -0,0 +1,73 @@
+require 'thor'
+require "thor/group"
+require "pry"
+
+module CodeSync
+  module Cli
+    class Base < Thor
+      class << self
+        def start(*args)
+          # Change flag to a module
+          ARGV.unshift("help") if ARGV.delete("--help")
+
+          # Default command is help
+          if ARGV[0] != "help" && (ARGV.length < 1 || ARGV.first.include?("-"))
+            ARGV.unshift("server")
+          end
+
+          super
+        end
+      end
+
+      desc "version", "Show version"
+      def version
+        require 'luca/version'
+        say "CodeSync #{CodeSync::Version}"
+      end
+
+      def help(meth = nil, subcommand = false)
+        if meth && !self.respond_to?(meth)
+          klass, task = Thor::Util.find_class_and_task_by_namespace("#{meth}:#{meth}")
+          klass.start(["-h", task].compact, :shell => self.shell)
+        else
+          list = []
+          Thor::Util.thor_classes_in(CodeSync::Cli).each do |klass|
+            list += klass.printable_tasks(false)
+          end
+          list.sort!{ |a,b| a[0] <=> b[0] }
+
+          shell.say "Tasks:"
+          shell.print_table(list, :ident => 2, :truncate => true)
+          shell.say
+        end
+      end
+
+      desc "start", "Starts the codesync project side server."
+      method_option :root, :default => Dir.pwd(), :required => false
+
+      def start
+        CodeSync::Manager.start(root: options[:root])
+      end
+
+      def method_missing(meth, *args)
+        meth = meth.to_s
+
+        if self.class.map.has_key?(meth)
+          meth = self.class.map[meth]
+        end
+
+        klass, task = Thor::Util.find_class_and_task_by_namespace("#{meth}:#{meth}")
+
+        if klass.nil?
+          super
+        else
+          args.unshift(task) if task
+          klass.start(args, :shell => self.shell)
+        end
+      end
+    end
+
+
+  end
+end
+

data/lib/code_sync/manager.rb

@@ -0,0 +1,238 @@
+require "code_sync/server"
+require "code_sync/sprockets_adapter"
+require "listen"
+require "pty"
+
+# In order to support the live-editing and immediate preview of
+# of precompiled assets in the browser or in the developers IDE
+# we need a background process that can integrate the file system
+# watcher, sprockets compiler environment, and rack process server.
+module CodeSync
+  class Manager
+
+    def self.start options={}
+      begin
+        manager = new(options)
+
+        cleanup_stale_processes
+
+        if options[:forked]
+          pid = fork do
+            manager.start
+          end
+
+          Process.detach(pid)
+        else
+          manager.start(options)
+        end
+      rescue
+        puts "Error Manager. #{ $! }"
+      ensure
+        puts "Clesning up finally"
+        cleanup_stale_processes
+      end
+    end
+
+    # FIXME:
+    # You know this aint right
+    def self.cleanup_stale_processes
+      PTY.spawn("ps aux |grep 'codesyn[c]'") do |stdin,stdout,pid|
+        stdin.each do |output|
+          if pid = output.split[1]
+            `kill -9 #{ pid }`
+          end
+        end
+      end
+    end
+
+    attr_accessor :sprockets, :server, :client_manager, :options, :processes, :process_map
+
+    def start options={}
+      if already_running?
+        puts "== Codesync is already running"
+        return
+      end
+
+      $0 = "codesync process: manager"
+
+      build_process_map
+
+      trap("SIGINT") do
+        exit_gracefully # :)
+      end
+
+
+      puts "== All CodeSync processes exited cleanly."
+    end
+
+    protected
+      def build_process_map
+        @process_map = processes.inject({}) do |memo,config|
+          name = config.first
+
+          memo[name] = pid = fork do
+            name, block = config
+
+            $0 = "codesync process: #{ name }"
+            block.call
+          end
+
+          memo
+        end
+
+        Process.waitall
+      end
+
+      def already_running?
+        test = `ps aux |grep "c[o]desync process: manager"`
+
+        test.match(/manager/)
+      end
+
+      def exit_gracefully
+        puts "EXIT"
+
+        yield if block_given?
+
+        puts "Didn't make it past yield"
+        puts "#{ process_map.inspect }"
+
+        process_map.each do |process_name,pid|
+          puts "Killing #{ process_name } #{pid}"
+
+          Process.kill(9,pid)
+        end
+      end
+
+      def initialize options={}
+        @options = options.freeze
+
+
+        create_server()
+
+        unless options[:disable_watcher]
+          puts "Listening for changes on the filesystem"
+          listen_for_changes_on_the_filesystem do |changed_assets|
+            changed_assets.each do |asset|
+              notify_clients_of_change_to(asset)
+            end
+          end
+        end
+
+        unless options[:enable_listener]
+          listen_for_changes_from_clients do |changed_assets|
+          end
+        end
+
+        unless options[:disable_internal_watch]
+          listen_for_changes_to_code_sync()
+        end
+      end
+
+      def create_server
+        @sprockets = SprocketsAdapter.new(root: root, sprockets: options[:sprockets])
+        @server = CodeSync::Server.new(assets: sprockets, root: root, forbid_saving: !!(options[:forbid_saving]) )
+
+        manage_child_process("server") do
+          server.start()
+        end
+      end
+
+      def notify_clients_of_change_to asset
+        payload = JSON.generate(asset)
+
+        puts "== Codesync detected change: #{ asset[:name] }"
+
+        EM.run do
+          pub = client.publish("/code-sync/outbound", asset)
+          pub.callback { EM.stop }
+        end
+      end
+
+      def client
+        @client = ::Faye::Client.new("http://localhost:9295/faye")
+      end
+
+      def listen_for_changes_from_clients &handler
+        manage_child_process("listener") do
+          EM.run do
+            client.subscribe("/code-sync/inbound") do |message|
+              puts "Received Code-Sync Inbound"
+              puts message.inspect
+            end
+          end
+        end
+      end
+
+      def listen_for_changes_to_code_sync &handler
+        manage_child_process("internal") do
+          internal.start
+        end
+      end
+
+      def listen_for_changes_on_the_filesystem &handler
+        manage_child_process("watcher") do
+          watcher.change do |modified,added,removed|
+            begin
+              handler.call process_changes_to(modified+added)
+            rescue
+              puts "Error handling changes: #{ $! }"
+            end
+          end
+
+          watcher.start
+        end
+      end
+
+      def manage_child_process name, &block
+        @processes ||= []
+        @processes << [name,block]
+      end
+
+      def process_changes_to assets
+        sprockets.process_changes_to(assets)
+      end
+
+      def root
+        base = options[:root] || options[:assets_directory] || Dir.pwd()
+      end
+
+      def internal
+        lib = File.dirname(__FILE__)
+        puts "Listening to #{ lib }"
+
+        @internal_watch = Listen.to( lib )
+          .filter(/.rb/)
+          .latency(1)
+          .change do
+            restart_everything!
+          end
+
+        @internal_watch
+      end
+
+      def restart_everything!
+
+      end
+
+      def watcher
+        if !@watcher
+          puts "Codesync watch is looking for assets in: #{ root }"
+        end
+
+        @watcher ||= Listen.to(root)
+                      .filter(assets_filter)
+                      .latency(1)
+      end
+
+      # TODO
+      # Provide for configurability
+      def assets_filter
+       /(\.coffee|\.css|\.jst|\.mustache\.js|\.sass)/
+      end
+
+      def method_missing meth, *args, &block
+        puts "Need to implement #{ meth }"
+      end
+  end
+end