synqa 0.0.3 → 0.1.0

data/Rakefile

@@ -40,7 +40,7 @@ Rcov::RcovTask.new do |test|
   test.verbose = true
 end
 
-task :default => :rdoc
+task :default => :test
 
 require 'rake/rdoctask'
 Rake::RDocTask.new do |rdoc|

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.1.0

data/examples/sample-rakefile

@@ -1,33 +1,21 @@
-
-# A redacted rakefile example using Synqa
-# In this example the source files are copied directly from ./src to
-# yourusername@yourhostname.example.com/home/username/public.
-# 
-# For a more complex static site, your rakefile might generate the site
-# into an output directory and upload from there.
-#
-# Tasks:
-#   clean - removes the cached content files
-#   upload - syncs local content with remote dir (i.e. uploads new/changed files 
-#            and deletes remote files that don't exist in the local dir
-#   uploaddry - a "dry run" for upload, doesn't actually upload or delete files
-
-require 'rejinnirate-rake'
-require 'synqa'  # This assumes synqa is installed as a gem, otherwise require 'synqa.rb'
+require 'based-directory'
+require 'synqa'
 require 'digest/sha2'
 
 STDOUT.sync = true
 
-include Rejinnirate
 include Synqa
 
 BASE_DIR = File.dirname(__FILE__)
 
 SRC_DIR = File.join(BASE_DIR, "src")
-UPLOAD_DIR = SRC_DIR
+
+UPLOAD_DIR = Based::BaseDirectory.new(SRC_DIR, 
+                                      :fileExclude => lambda{|file| file.name.end_with?("~")})
+
 SYNQA_DIR = File.join(BASE_DIR, "output", "synqa")
   
-task :default => [:upload] do |t|
+task :default => [:uploaddry] do |t|
 end
 
 REMOTE_HOST = SshContentHost.new("yourusername@yourhostname.example.com", 
@@ -39,8 +27,7 @@ REMOTE_SITE = RemoteContentLocation.new(REMOTE_HOST,
 
 LOCAL_SITE = LocalContentLocation.new(UPLOAD_DIR, 
                                       Digest::SHA256, 
-                                      File.join(SYNQA_DIR, "localContent.txt"), 
-                                      :excludes => ["*\\~", "**/*\\~"])
+                                      File.join(SYNQA_DIR, "localContent.txt"))
 
 task :init do |t|
   ensureDirectoryExists(SYNQA_DIR)

data/examples/synqa-useage.rb

@@ -1,6 +1,7 @@
 # Sample code for synqa useage -- you will need to fill in your own details
 
 require 'synqa.rb'
+require 'based-directory'
 require 'digest/sha2'
 
 STDOUT.sync = true
@@ -9,7 +10,7 @@ include Synqa
 sha256Sum = Sha256SumCommand.new()    # sha256sum (with 2 characters between hash and file name)
 sha256 = Sha256Command.new()          # sha256 -r (with 1 space between hash and file name)
 
-localContentLocation = LocalContentLocation.new("c:/dev/src/project", 
+localContentLocation = LocalContentLocation.new(Based::BaseDirectory.new("c:/dev/src/project"), 
                                                 Digest::SHA256, 
                                                 "c:/temp/synqa/local.project.content.cache.txt")
 

data/lib/based-directory.rb

@@ -0,0 +1,177 @@
+# The Based module supports the concept of a "based" directory. Typically in modern software development, 
+# a project is represented by a set of sub-directories and files within a base directory. The exact location
+# of the base directory is not so important (i.e. it's wherever you checked it out of source control). For a given
+# file or sub-directory, one is often more interested in the path relative to the base directory, rather than 
+# the absolute path. (But you still need the full path when performing an actual file operation on the file
+# or directory.)
+# Also, there might be files and directories that you wish to ignore. Based supports simple functional includes and
+# excludes. (A bit less succint than include/exclude globs, but probably more flexible.)
+
+module Based
+  
+  # A base class for directories: i.e. either the base directory itself, or a sub-directory
+  class Directory
+    # The base directory (object)
+    attr_reader :base
+    
+    # The path of this directory relative to the base directory (includes a following "/" if non-empty)
+    attr_reader :relativePath
+    
+    # The elements of the relative path as an array
+    attr_reader :pathElements
+    
+    # The immediate name of the directory (nil for the base directory)
+    attr_reader :name
+    
+    # The parent directory (nil for the base directory)
+    attr_reader :parent
+    
+    # The full path of the file
+    attr_reader :fullPath
+    
+    # initialise with un-initialised entries
+    def initialize
+      @entries = nil
+    end
+    
+    # get the "entries", i.e. list of files and directories immediately contained in this directory, and cache them.
+    # Note that dirExclude, fileInclude and fileExclude functions in the base directory object
+    # may be applied to filter out some entries.
+    def getEntries
+      if @entries == nil
+        @entries = Dir.entries(fullPath)
+        @dirs = []
+        @files = []
+        for entry in @entries
+          if entry != "." and entry != ".." 
+            fullEntryPath = fullPath + entry
+            if ::File.directory?(fullEntryPath)
+              subDirectory = SubDirectory.new(entry, self)
+              if @base.dirExclude == nil or not @base.dirExclude.call(subDirectory)
+                @dirs << subDirectory
+              end
+            elsif ::File.file?(fullEntryPath)
+              file = File.new(entry, self)
+              if @base.fileInclude == nil or @base.fileInclude.call(file)
+                if @base.fileExclude == nil or not @base.fileExclude.call(file)
+                  @files << file
+                end
+              end
+            end
+          end
+        end
+        @dirs.sort_by! {|dir| dir.name}
+        @files.sort_by! {|file| file.name}
+      end
+    end
+    
+    # Get list of files immediately contained in this directory
+    def files
+      getEntries()
+      return @files
+    end
+    
+    # Get list of directories immediately contained in this directory
+    def dirs
+      getEntries()
+      return @dirs
+    end
+    
+    # Get a list of all the sub-directories of this directory (with parents preceding children)
+    def subDirs
+      result = []
+      for dir in dirs
+        result << dir
+        result += dir.subDirs
+      end
+      return result
+    end
+    
+    # Get a list of all files contained within this directory
+    def allFiles
+      result = files
+      for subDir in subDirs
+        result += subDir.files
+      end
+      return result
+    end
+  end
+  
+  # An object representing a sub-directory (i.e. not the base directory itself)
+  class SubDirectory<Directory
+    
+    # Construct directory object from parent directory object and this directory's name
+    def initialize(name, parent)
+      super()
+      @name = name
+      @parent = parent
+      @base = @parent.base
+      @relativePath = @parent.relativePath + @name + "/"
+      @pathElements = @parent.pathElements + [name]
+      @fullPath = @parent.fullPath + @name + "/"
+    end
+  end
+  
+  # An object representing the base directory
+  class BaseDirectory<Directory
+    
+    # Function to decide if files should be included (if nil, assume all included). Subject
+    # to exclusion by fileExclude
+    attr_reader :fileInclude
+    
+    # Function to decide if files should be excluded
+    attr_reader :fileExclude
+    
+    # Function to decide if sub-directories should be excluded (if a directory is excluded, so 
+    # are all it's sub-directories and files contained within)
+    attr_reader :dirExclude
+    
+    # Initialise from absolute file path. Options include :dirExclude, :fileInclude and :fileExclude
+    def initialize(path, options = {})
+      super()
+      @name = nil
+      @parent = nil
+      @base = self
+      @relativePath = ""
+      @pathElements = []
+      @fullPath = path.end_with?("/") ? path : path + "/"
+      @dirExclude = options.fetch(:dirExclude, nil)
+      @fileInclude = options.fetch(:fileInclude, nil)
+      @fileExclude = options.fetch(:fileExclude, nil)
+    end
+  end
+  
+  # An object representing a file within the base directory
+  class File
+    # immediate name of file
+    attr_reader :name
+    
+    # parent, i.e. containing directory
+    attr_reader :parent
+    
+    # the base directory
+    attr_reader :base
+    
+    # path of this file relative to base directory
+    attr_reader :relativePath
+    
+    # elements of file path (including the name) as an array
+    attr_reader :pathElements
+    
+    # full absolute path name of file
+    attr_reader :fullPath
+    
+    # initialise from name and containing directory
+    def initialize(name, parent)
+      super()
+      @name = name
+      @parent = parent
+      @base = @parent.base
+      @relativePath = @parent.relativePath + @name
+      @pathElements = @parent.pathElements + [name]
+      @fullPath = @parent.fullPath + @name
+    end
+    
+  end
+  
+end

data/lib/synqa.rb

@@ -2,6 +2,17 @@ require 'time'
 
 module Synqa
 
+  # ensure that a directory exists
+  def ensureDirectoryExists(directoryName)
+    if File.exist? directoryName
+      if not File.directory? directoryName
+        raise "#{directoryName} is a non-directory file"
+      end
+    else
+      FileUtils.makedirs(directoryName)
+    end
+  end
+
   # Check if the last executed process exited with status 0, if not, raise an exception
   def checkProcessStatus(description)
     processStatus = $?
@@ -400,7 +411,7 @@ module Synqa
     def sort!
       dirs.sort_by! {|dir| dir.name}
       files.sort_by! {|file| file.name}
-      for dir in dirs do
+      for dir in dirs
         dir.sort!
       end
     end
@@ -441,10 +452,10 @@ module Synqa
         puts "#{currentIndent} [DELETE]"
       end
       nextIndent = currentIndent + indent
-      for dir in dirs do
+      for dir in dirs
         dir.showIndented("#{dir.name}/", indent = indent, currentIndent = nextIndent)
       end
-      for file in files do
+      for file in files
         puts "#{nextIndent}#{file.name}  - #{file.hash}"
         if file.copyDestination != nil
           puts "#{nextIndent} [COPY to #{file.copyDestination.fullPath}]"
@@ -460,11 +471,11 @@ module Synqa
       if time != nil
         outFile.puts("T #{time.strftime(@@dateTimeFormat)}\n")
       end
-      for dir in dirs do
+      for dir in dirs
         outFile.puts("D #{prefix}#{dir.name}\n")
         dir.writeLinesToFile(outFile, "#{prefix}#{dir.name}/")
       end
-      for file in files do
+      for file in files
         outFile.puts("F #{file.hash} #{prefix}#{file.name}\n")
       end
     end
@@ -654,26 +665,16 @@ module Synqa
   # can be calculated directly using Ruby library functions.
   class LocalContentLocation<ContentLocation
     
-    # the base directory
-    attr_reader :baseDir
+    # the base directory, for example of type Based::BaseDirectory. Methods invoked are: allFiles, subDirs and fullPath.
+    # For file and dir objects returned by allFiles & subDirs, methods invoked are: relativePath and fullPath
+    attr_reader :baseDirectory
     # the ruby class that generates the hash, e.g. Digest::SHA256
     attr_reader :hashClass
     
-    def initialize(baseDir, hashClass, cachedContentFile = nil, options = {})
+    def initialize(baseDirectory, hashClass, cachedContentFile = nil)
       super(cachedContentFile)
-      @baseDir = normalisedDir(baseDir)
-      @baseDirLen = @baseDir.length
+      @baseDirectory = baseDirectory
       @hashClass = hashClass
-      @excludeGlobs = options.fetch(:excludes, [])
-    end
-    
-    # get the path of a file name relative to the base directory
-    def getRelativePath(fileName)
-      if fileName.start_with? @baseDir
-        return fileName[@baseDirLen..-1]
-      else
-        raise "File name #{fileName} does not start with #{baseDir}"
-      end
     end
     
     # get the path as required for an SCP command
@@ -683,18 +684,7 @@ module Synqa
     
     # get the full path of a relative path (i.e. of a file/directory within the base directory)
     def getFullPath(relativePath)
-      return @baseDir + relativePath
-    end
-    
-    # is the relative path name excluded by one of the specified exclusion globs?
-    def fileIsExcluded?(relativeFile)
-      for excludeGlob in @excludeGlobs
-        if File.fnmatch(excludeGlob, relativeFile)
-          puts "   file #{relativeFile} excluded by glob #{excludeGlob}"
-          return true
-        end
-      end
-      return false
+      return @baseDirectory.fullPath + relativePath
     end
     
     # get the content tree for this base directory by iterating over all
@@ -709,25 +699,17 @@ module Synqa
       cachedMapOfHashes = cachedTimeAndMapOfHashes[1]
       contentTree = ContentTree.new()
       contentTree.time = Time.now.utc
-      #puts "LocalContentLocation.getContentTree for baseDir #{baseDir} ..."
-      for fileOrDir in Dir.glob(baseDir + "**/*", File::FNM_DOTMATCH)
-        if not (fileOrDir.end_with?("/.") or fileOrDir.end_with?("/.."))
-          relativePath = getRelativePath(fileOrDir)
-          #puts " #{relativePath}"
-          if File.directory? fileOrDir
-            contentTree.addDir(relativePath)
-          else
-            if not fileIsExcluded?(relativePath)
-              cachedDigest = cachedMapOfHashes[relativePath]
-              if cachedTime and cachedDigest and File.stat(fileOrDir).mtime < cachedTime
-                digest = cachedDigest
-              else
-                digest = hashClass.file(fileOrDir).hexdigest
-              end
-              contentTree.addFile(relativePath, digest)
-            end
-          end
+      for subDir in @baseDirectory.subDirs
+        contentTree.addDir(subDir.relativePath)
+      end
+      for file in @baseDirectory.allFiles
+        cachedDigest = cachedMapOfHashes[file.relativePath]
+        if cachedTime and cachedDigest and File.stat(file.fullPath).mtime < cachedTime
+          digest = cachedDigest
+        else
+          digest = hashClass.file(file.fullPath).hexdigest
         end
+        contentTree.addFile(file.relativePath, digest)
       end
       contentTree.sort!
       if cachedContentFile != nil
@@ -892,7 +874,7 @@ module Synqa
     # Recursively perform all marked copy operations from the source content tree to the
     # destination content tree, or if dryRun, just pretend to perform them.
     def doCopyOperations(sourceContent, destinationContent, dryRun)
-      for dir in sourceContent.dirs do
+      for dir in sourceContent.dirs
         if dir.copyDestination != nil
           sourcePath = sourceLocation.getScpPath(dir.fullPath)
           destinationPath = destinationLocation.getScpPath(dir.copyDestination.fullPath)
@@ -901,7 +883,7 @@ module Synqa
           doCopyOperations(dir, destinationContent.getDir(dir.name), dryRun)
         end
       end
-      for file in sourceContent.files do
+      for file in sourceContent.files
         if file.copyDestination != nil
           sourcePath = sourceLocation.getScpPath(file.fullPath)
           destinationPath = destinationLocation.getScpPath(file.copyDestination.fullPath)
@@ -913,7 +895,7 @@ module Synqa
     # Recursively perform all marked delete operations on the destination content tree, 
     # or if dryRun, just pretend to perform them.
     def doDeleteOperations(destinationContent, dryRun)
-      for dir in destinationContent.dirs do
+      for dir in destinationContent.dirs
         if dir.toBeDeleted
           dirPath = destinationLocation.getFullPath(dir.fullPath)
           destinationLocation.ssh("rm -r #{dirPath}", dryRun)
@@ -921,7 +903,7 @@ module Synqa
           doDeleteOperations(dir, dryRun)
         end
       end
-      for file in destinationContent.files do
+      for file in destinationContent.files
         if file.toBeDeleted
           filePath = destinationLocation.getFullPath(file.fullPath)
           destinationLocation.ssh("rm #{filePath}", dryRun)

data/test/data/dir1/dir2/dir4/dir5/file6.text

@@ -0,0 +1 @@
+This is file 6.

data/test/data/dir1/dir2/dir4/file5.text

@@ -0,0 +1 @@
+File 5, with different extension.

data/test/data/dir1/dir2/file3.txt

@@ -0,0 +1 @@
+This is a third file, inside a sub-directory.

data/test/data/dir1/dir3/file1.txt

@@ -0,0 +1 @@
+Another file 1

data/test/data/dir1/file1.txt

@@ -0,0 +1 @@
+This is a file 1.

data/test/data/dir1/file2.txt

@@ -0,0 +1 @@
+This is a second file.

data/test/test_based_directory.rb

@@ -0,0 +1,114 @@
+require 'helper'
+
+require 'based-directory'
+
+module Based
+  
+  class BaseDirectoryTestCase < Test::Unit::TestCase
+    include Based
+  end
+
+  class TestBaseDirectory < BaseDirectoryTestCase
+    context "A base directory" do
+      setup do
+        @baseDirPath = ::File.expand_path(::File.join(::File.dirname(__FILE__), "data", "dir1"))
+        #puts "@baseDirPath = #{@baseDirPath}"
+        @baseDir = BaseDirectory.new(@baseDirPath)
+      end
+      
+      should "not add / if already in base bath" do
+        @baseDir2 = BaseDirectory.new(@baseDirPath + "/")
+        assert_equal "#{@baseDirPath}/", @baseDir.fullPath
+        dir2 = @baseDir.dirs[0]
+        assert_equal "dir2", dir2.name
+      end
+      
+      should "find files in top-level directory and get their names and relative paths" do
+        names = @baseDir.files.map {|file| file.name}
+        assert_equal ["file1.txt", "file2.txt"], names
+        relativePaths = @baseDir.files.map {|file| file.relativePath}
+        assert_equal ["file1.txt", "file2.txt"], relativePaths
+      end
+      
+      should "check attributes of basedir" do
+        assert_equal nil, @baseDir.name
+        assert_equal nil, @baseDir.parent
+        assert_equal @baseDir, @baseDir.base
+        assert_equal "", @baseDir.relativePath
+        assert_equal [], @baseDir.pathElements
+        assert_equal "#{@baseDirPath}/", @baseDir.fullPath
+      end
+      
+      should "find one directory and check all its attributes" do
+        dir2 = @baseDir.dirs[0]
+        dir4 = dir2.dirs[0]
+        assert_equal "dir4", dir4.name
+        assert_equal dir2, dir4.parent
+        assert_equal @baseDir, dir4.base
+        assert_equal "dir2/dir4/", dir4.relativePath
+        assert_equal ["dir2", "dir4"], dir4.pathElements
+        assert_equal "#{@baseDirPath}/dir2/dir4/", dir4.fullPath
+      end
+      
+      should "find one file and check all its attributes" do
+        dir2 = @baseDir.dirs[0]
+        dir4 = dir2.dirs[0]
+        file5 = dir4.files[0]
+        assert_equal "file5.text", file5.name
+        assert_equal dir4, file5.parent
+        assert_equal @baseDir, file5.base
+        assert_equal "dir2/dir4/file5.text", file5.relativePath
+        assert_equal ["dir2", "dir4", "file5.text"], file5.pathElements
+        assert_equal "#{@baseDirPath}/dir2/dir4/file5.text", file5.fullPath
+      end
+      
+      should "find sub-directories in top-level directory and get their names and relative paths" do
+        names = @baseDir.dirs.map {|dir| dir.name}
+        assert_equal ["dir2", "dir3"], names
+        relativePaths = @baseDir.dirs.map {|dir| dir.relativePath}
+        assert_equal ["dir2/", "dir3/"], relativePaths
+      end
+      
+      should "find all sub-directories of base directory" do
+        relativePaths = @baseDir.subDirs.map{|dir| dir.relativePath}
+        assert_equal ["dir2/", "dir2/dir4/", "dir2/dir4/dir5/", "dir3/"], relativePaths
+      end
+      
+      should "find all files within base directory" do
+        relativePaths = @baseDir.allFiles.map{|dir| dir.relativePath}
+        assert_equal ["file1.txt", "file2.txt", "dir2/file3.txt", "dir2/dir4/file5.text", 
+                      "dir2/dir4/dir5/file6.text", "dir3/file1.txt"], relativePaths
+      end
+      
+      should "exclude dir2" do
+        filteredBaseDir = BaseDirectory.new(@baseDirPath,
+                                            :dirExclude => lambda{|dir| dir.name == "dir2"})
+        relativePaths = filteredBaseDir.allFiles.map{|file| file.relativePath}
+        assert_equal ["file1.txt", "file2.txt", "dir3/file1.txt"], relativePaths
+      end
+      
+      should "include only .txt files" do
+        filteredBaseDir = BaseDirectory.new(@baseDirPath,
+                                            :fileInclude => lambda{|file| file.name.end_with? ".txt"})
+        relativePaths = filteredBaseDir.allFiles.map{|file| file.relativePath}
+        assert_equal ["file1.txt", "file2.txt", "dir2/file3.txt", 
+                      "dir3/file1.txt"], relativePaths
+      end
+      
+      should "not include .txt files" do
+        filteredBaseDir = BaseDirectory.new(@baseDirPath,
+                                            :fileExclude => lambda{|file| file.name.end_with? ".txt"})
+        relativePaths = filteredBaseDir.allFiles.map{|file| file.relativePath}
+        assert_equal ["dir2/dir4/file5.text", "dir2/dir4/dir5/file6.text"], relativePaths
+      end
+      
+      should "include only .txt files not in dir3" do
+        filteredBaseDir = BaseDirectory.new(@baseDirPath,
+                                            :dirExclude => lambda{|dir| dir.name == "dir3"}, 
+                                            :fileInclude => lambda{|file| file.name.end_with? ".txt"})
+        relativePaths = filteredBaseDir.allFiles.map{|file| file.relativePath}
+        assert_equal ["file1.txt", "file2.txt", "dir2/file3.txt"], relativePaths
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: synqa
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-03-02 00:00:00.000000000 +13:00
+date: 2011-03-19 00:00:00.000000000 +13:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &24960612 !ruby/object:Gem::Requirement
+  requirement: &24879420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *24960612
+  version_requirements: *24879420
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &24959928 !ruby/object:Gem::Requirement
+  requirement: &24878820 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *24959928
+  version_requirements: *24878820
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &24942648 !ruby/object:Gem::Requirement
+  requirement: &24878220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *24942648
+  version_requirements: *24878220
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &24941832 !ruby/object:Gem::Requirement
+  requirement: &24877560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +55,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *24941832
+  version_requirements: *24877560
 description: Sync files from a local directory to a remote directory via SSH/SCP
 email: http://www.1729.com/email.html
 executables: []
@@ -74,8 +74,16 @@ files:
 - _project.el
 - examples/sample-rakefile
 - examples/synqa-useage.rb
+- lib/based-directory.rb
 - lib/synqa.rb
+- test/data/dir1/dir2/dir4/dir5/file6.text
+- test/data/dir1/dir2/dir4/file5.text
+- test/data/dir1/dir2/file3.txt
+- test/data/dir1/dir3/file1.txt
+- test/data/dir1/file1.txt
+- test/data/dir1/file2.txt
 - test/helper.rb
+- test/test_based_directory.rb
 - test/test_synqa.rb
 has_rdoc: true
 homepage: http://www.1729.com/software/synqa/
@@ -93,7 +101,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 346342291
+      hash: 537622927
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -109,4 +117,5 @@ summary: Sync files from a local directory to a remote directory via SSH/SCP
 test_files:
 - examples/synqa-useage.rb
 - test/helper.rb
+- test/test_based_directory.rb
 - test/test_synqa.rb