unitylock 0.1.0

data/app/src/row.js

@@ -0,0 +1,60 @@
+class Row {
+  constructor(path, helper) {
+    this.path = path
+    this.helper = helper
+  }
+
+  // TODO: sync
+  lock (user) {
+    return new Promise((resolve, reject) => {
+      helper.fetch_by_path(this.path)
+        .then(row => {
+          if (row === undefined) {
+            reject("Not found lock object.")
+            return 
+          }
+
+          if (row.owner != null) {
+            reject("Owner already exist.")
+            return
+          }
+
+          this.owner = user
+          helper
+            .create_or_update_rows([this])
+            .then(row => resolve(this))
+            .catch(err => reject(err))
+        })
+    })
+  }
+
+  // TODO: sync
+  unlock (user) {
+    var row = helper.fetch_by_path(this.path)
+    if (row === undefined) {
+      return false
+    }
+
+    if (row.owner != user) {
+      return false
+    }
+
+    this.owner = null
+    helper.create_or_update_rows([this])
+    return true
+  }
+
+  delete () {
+    helper.delete_by_path(this.path)
+  }
+
+  static touches(helper, pathes) {
+    helper.create_or_update_rows(pathes)
+  }
+
+  static list(helper) {
+    helper.search()
+  }
+}
+
+export default Row

data/app/src/socket.js

@@ -0,0 +1,47 @@
+var port            = process.env.WEBSOCKET_PORT || 8080;
+var WebSocketServer = require('websocket').server;
+var http            = require('http');
+var server          = http.createServer(function(request, response) {
+    console.log((new Date()) + ' Received request for ' + request.url);
+    response.writeHead(404);
+    response.end();
+});
+
+server.listen(port, function() {
+    console.log((new Date()) + ' WebSocket port is ' + port);
+});
+ 
+var wsServer = new WebSocketServer({
+    httpServer: server,
+    autoAcceptConnections: false
+});
+ 
+function originIsAllowed(origin) {
+  return true;
+}
+ 
+wsServer.on('request', function(request) {
+    if (!originIsAllowed(request.origin)) {
+      // Make sure we only accept requests from an allowed origin 
+      request.reject();
+      console.log((new Date()) + ' Connection from origin ' + request.origin + ' rejected.');
+      return;
+    }
+    
+    var connection = request.accept('echo-protocol', request.origin);
+    console.log((new Date()) + ' Connection accepted.');
+    connection.on('message', function(message) {
+        if (message.type === 'utf8') {
+            console.log('Received Message: ' + message.utf8Data);
+            connection.sendUTF(message.utf8Data);
+        }
+        else if (message.type === 'binary') {
+            console.log('Received Binary Message of ' + message.binaryData.length + ' bytes');
+            connection.sendBytes(message.binaryData);
+        }
+    });
+    connection.on('close', function(reasonCode, description) {
+        console.log((new Date()) + ' Peer ' + connection.remoteAddress + ' disconnected.');
+    });
+});
+

data/app/test/helper.spec.js

@@ -0,0 +1,47 @@
+import assert from 'assert'
+import fs     from 'fs'
+import Helper from '../src/helper.js'
+import Row    from '../src/row.js'
+let test_file = 'test.lock'
+
+describe('Helper', () => {
+  beforeEach((done) => {
+    fs.unlink(test_file, (err) => {
+      done()
+    })
+  })
+
+  it('can instantiate', () => {
+    assert.ok(new Helper(test_file) != null, "Helper is not null")
+  })
+
+  it('can search when initialized', (done) => {
+    new Helper(test_file)
+      .search()
+      .then(rows => {
+        assert.ok(rows.length == 0, "length should be zero")
+        done()
+      })
+      .catch(err => {
+        assert.ok(err == null, "should not raise error")
+        done()
+      })
+  })
+
+  it('can create_or_update_by_pathes', (done) => {
+    new Helper(test_file)
+      .create_or_update_by_pathes(["key1", "key2"])
+      .then(rows => {
+        assert.equal(2, rows.length, "length should be two")
+        assert.equal("key1", rows[0].path, "path should not be null")
+        assert.ok(null != rows[0].updated_at, "updated_at should not be null")
+        assert.equal("key2", rows[1].path, "path should not be null")
+        assert.ok(null != rows[1].updated_at, "updated_at should not be null")
+        done()
+      })
+      .catch(err => {
+        assert.ok(err == null, "should not raise error")
+        done()
+      })
+  })
+})

data/app/utils/FileUtils.js

@@ -0,0 +1,11 @@
+function basename(path) {
+  var base = new String(path).substring(path.lastIndexOf('/') + 1)
+
+  if (base.lastIndexOf() != -1) {
+    base = base.substring(0, base.lastIndexOf('.'))
+  }
+
+  return base
+}
+
+export { basename }

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "unitylock/server"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/config.ru

@@ -0,0 +1,4 @@
+require 'sinatra/base'
+require 'unitylock/server'
+
+run Unitylock::Server::Main

data/config/puma.rb

@@ -0,0 +1,9 @@
+workers Integer(ENV['WEB_CONCURRENCY'] || 2)
+threads_count = Integer(ENV['MAX_THREADS'] || 5)
+threads threads_count, threads_count
+
+preload_app!
+
+rackup      DefaultRackup
+port        ENV['PORT']     || 3000
+environment ENV['RACK_ENV'] || 'development'

data/exe/unitylock

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+require 'unitylock/client'
+require 'optparse'
+
+PROJECT_CONFIG_FILE = '.unitylock'
+
+params         = ARGV.getopts('', 'user:', 'force')
+command        = ARGV.shift
+project_config = File.exists?(PROJECT_CONFIG_FILE) ? JSON.parse(File.read(PROJECT_CONFIG_FILE), {symbolize_names: true}) : {}
+url            = project_config[:url] || 'http://localhost:3000'
+client         = Unitylock::Client::Main.new(url)
+
+case command
+when "search" then
+  puts client.search.body
+when "touches" then
+  puts client.touches(ARGV).body
+when "deletes" then
+  puts client.deletes(ARGV).body
+when "delete_all" then
+  puts client.delete_all.body
+when "lock" then
+  user = params['user']
+  raise "requires parameter 'file'" unless ARGV.size > 0
+  raise "requires parameter 'user'" unless user != nil
+  puts client.locks(user: user, files: ARGV)
+when "unlock" then
+  user = params['user']
+  raise "requires parameter 'file'" unless ARGV.size > 0
+  raise "requires parameter 'user'" unless user != nil
+  puts client.unlocks(user: user, files: ARGV)
+when 'init' then
+  print 'url (http://localhost:3000): '
+  url = gets.chomp.sub(/^$/, 'http://localhost:3000')
+  File.write(PROJECT_CONFIG_FILE, JSON.pretty_generate({url: url}))
+  puts 'Created .unitylock'
+when 'sync' then
+  force = params['force'] || false
+  client.sync(dir: '.', force: force)
+else
+  puts "undefined command"
+  exit 1
+end
+

data/lib/unitylock/client.rb

@@ -0,0 +1,2 @@
+require 'unitylock/version'
+require 'unitylock/client/main'

data/lib/unitylock/client/main.rb

@@ -0,0 +1,90 @@
+require 'faraday'
+require 'json'
+require 'find'
+
+module Unitylock
+  module Client
+    class Main
+      def initialize(urlbase)
+        @conn = Faraday.new(:url => urlbase) do |faraday|
+          faraday.request  :url_encoded
+          # faraday.response :logger
+          faraday.adapter  Faraday.default_adapter
+        end
+      end
+
+      def search
+        @conn.get '/files'
+      end
+
+      def touches(files)
+        @conn.post do |req|
+          req.url '/files'
+          req.headers['Content-Type'] = 'application/json'
+          req.body = JSON.generate(files)
+        end
+      end
+
+      def deletes(files)
+        @conn.delete do |req|
+          req.url '/files'
+          req.headers['Content-Type'] = 'application/json'
+          req.body = JSON.generate(files)
+        end
+      end
+
+      def delete_all
+        files = JSON.parse(search.body).collect {|it| it['file']}
+        deletes(files)
+      end
+
+      def locks(user:, files:)
+        # TODO: requests at once
+        results = []
+        files.each do |file|
+          results << @conn.put do |req|
+            req.url "/user/#{user}/lock"
+            req.headers['Content-Type'] = 'application/json'
+            req.body = JSON.generate({file: file})
+          end.body
+        end
+        results
+      end
+
+      def unlocks(user:, files:)
+        # TODO: requests at once
+        results = []
+        files.each do |file|
+          results << @conn.put do |req|
+            req.url "/user/#{user}/unlock"
+            req.headers['Content-Type'] = 'application/json'
+            req.body = JSON.generate({file: file})
+          end.body
+        end
+        results
+      end
+
+      def sync(dir: '.', force: false, includes: /\.(unity|prefab)$/, excludes: /^$/)
+        files = Find.find(dir).select{|it| it =~ includes}.select{|it| it !~ excludes}
+
+        puts "touched:"
+        puts files
+
+        touches(files)
+        touched_files = JSON.parse(search.body).collect {|it| it['file']}
+
+        if force
+          remove_files = touched_files.select{|it| !files.include?(it) }
+
+          puts "removed:"
+          puts remove_files
+
+          deletes(remove_files)
+          return (touched_files - remove_files)
+        end
+
+        return touched_files
+      end
+    end
+  end
+end

data/lib/unitylock/server.rb

@@ -0,0 +1,2 @@
+require 'unitylock/version'
+require 'unitylock/server/router'

data/lib/unitylock/server/entity/unityfile.rb

@@ -0,0 +1,38 @@
+require 'json/add/core'
+
+module Unitylock
+  module Server
+    module Entity
+      class UnityFile < Struct.new(:user,:file,:updated_at)
+        def update
+          self.updated_at = Time.now
+          self
+        end
+
+        def to_hash
+          {
+            user: self.user,
+            file: self.file,
+            updated_at: self.updated_at.strftime("%Y-%m-%d %H:%M:%S")
+          }
+        end
+
+        class << self
+          def json_create(o)
+            new(*o['v'])
+          end
+
+          def create(hash)
+            unityfile = UnityFile.new
+            default_values = { updated_at: Time.now }
+            default_values.merge(hash).each do |key,value|
+              unityfile[key] = value
+            end
+
+            unityfile
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unitylock/server/model.rb

@@ -0,0 +1,59 @@
+require 'ostruct'
+require 'json'
+require 'unitylock/server/entity/unityfile'
+
+include Unitylock::Server::Entity
+module Unitylock
+  module Server
+    class Model
+      attr_accessor :data, :file
+
+      def initialize(file)
+        @file = file
+        File.write(@file, '{}') unless File.exists? @file
+        load
+      end
+
+      def load
+        @data = JSON.parse(File.read(@file), create_additions: true)
+      end
+
+      def save
+        File.write(@file, JSON.generate(@data))
+      end
+
+      def delete(file:)
+        @data.delete(file)
+        save
+      end
+
+      def lock(file:, user:)
+        raise "lock failure" unless @data.has_key?(file) && @data[file].user == nil
+        @data[file] = UnityFile.create(file: file, user: user)
+        save
+        @data[file]
+      end
+
+      def unlock(file:, user:) 
+        raise "unlock failure" unless @data.has_key?(file) && @data[file].user == user
+        @data[file] = UnityFile.create(file: file, user: nil)
+        save
+        @data[file]
+      end
+
+      def create_or_update(file:)
+        @data[file] ||= UnityFile.create(file: file)
+        @data[file].update
+        save
+      end
+
+      def search
+        @data.map {|key,value| value}
+      end
+
+      def fetch(file:)
+        @data[file]
+      end
+    end
+  end
+end