rsync_config 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2eec2099c07ff331d789ae499f3487d9cbbf2371
+  data.tar.gz: d0af2a1154084f0fff7aab650f68cbdf0a0cff9c
+SHA512:
+  metadata.gz: 44661fc4d9f091e2760e11a16e85219cb779b21c769728006e3b6fd7e74a7ab6c005db042aa8a3e04f61753c6b7617890173762b0b2423ed1e6e137c23556314
+  data.tar.gz: 8bb05a02d50ed6e99acfdefb4b873677cdc57a268f584e5d8df551fafb212b806ed7933cc8f78171f0adccaf25f7a40bcd91cc5ad03d58ecd5916b3f58e8a1ce

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rsync_config.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Guillaume Bodi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# RsyncConfig
+
+This is a little utility gem to help manage the rsyncd config files on GNU/Linux systems.
+It is still in infancy but is usable as is.
+
+[![Code Climate](https://codeclimate.com/github/kuma-giyomu/rsync_config.png)](https://codeclimate.com/github/kuma-giyomu/rsync_config)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rsync_config'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rsync_config
+
+## Usage
+
+You can load a config file using `RsyncConfig::load_config <file_path>` or create a config from scratch with `RsyncConfig::Config.new`.
+Alternatively, you can use `RsyncConfig::parse <content>` if you prefer to provide the input from a random source.
+
+### Properties
+
+The `RsyncConfig::Config` instance provides access to properties via the `#[]` and `#[]=` methods. So for instance 
+
+```ruby
+config = RsyncConfig::Config.new
+config['uid'] = 'alice' # setter
+puts config['uid']      # getter
+```
+
+Note that the class accepts symbols as alternative `config[:uid]` is valid too.
+But I felt it was best to keep as strings for the config options with spaces such as `secrets file`.
+
+### Modules
+
+The `RsyncConfig::Config` instance provides access to modules via the `#module` method
+
+```ruby
+config = RsyncConfig::Config.new
+foo_module = config.module :foo
+bar_module = config.module 'bar'
+```
+
+Here again, symbols are converted to strings (rsync allows modules with spaces and whatnot)
+
+Properties can be assigned to modules in the same way they are added to the `RsyncConfig::Config` object.
+
+```ruby
+foo_module['uid'] = 'alice'
+```
+
+`RsyncConfig::Module` instances do not have modules themselves.
+
+### Users
+
+Both `RsyncConfig::Config` and `RsyncConfig::Module` instances can define a list of users that have access to the modules.
+They are defined using the `#users` hash accessor method.
+Additionally a test method `#user?` can be used to probe for a give user's existence.
+
+```ruby
+config = RsyncConfig::Config.new
+config.users = {'alice' => 'wonder'}
+puts config.user?('alice') # true
+config.users['bob'] = 'march'
+```
+
+### Writing to disk
+
+Use `RsyncConfig::Config#write_to <main_output_file>`.
+The gem assumes that you have write permissions on the file and a `RuntimeError` will be raised otherwise.
+This method will automatically try to write the secrets files when defined.
+
+For a raw String output, just call `RsyncConfig::Config#to_config_file` instead.
+Note that this method will not return the content of the secrets file (not sure if this will be useful).
+
+### Limitations
+
+- currently the gem does not process the directives `&include` and `&merge`.
+- the values for the properties are not checked/validated in any way.
+- the way secrets files are handled is simplistic since the files will be written/read multiple times if specified more than once
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+	t.libs << 'lib'
+	t.libs << 'test'
+	t.test_files = FileList['test/test*.rb']
+end

data/lib/rsync_config/config.rb

@@ -0,0 +1,112 @@
+module RsyncConfig
+
+  class Config
+
+    include Propertiable
+    include UserManagement
+
+    # global properties
+    allow_properties :motd_file, :pid_file, :port, :address, :socket_options, :listen_backlog
+
+    # module properties
+    allow_properties :comment, :path, :use_chroot, :numeric_ids, :munge_symlinks, :charset
+    allow_properties :max_connections, :log_file, :syslog_facility, :max_verbosity, :lock_file
+    allow_properties :read_only, :write_only, :list, :uid, :gid, :fake_super, :filter, :exclude, :include
+    allow_properties :exclude_from, :include_from, :incoming_chmod, :outgoing_chmod, :auth_users
+    allow_properties :secrets_file, :strict_modes, :hosts_allow, :hosts_deny, :reverse_lookup
+    allow_properties :forward_lookup, :ignore_errors, :ignore_nonreadable, :transfer_logging
+    allow_properties :log_format, :timeout, :refuse_options, :dont_compress, 'pre-xfer exec', 'post-xfer exec'
+
+    def self.load_file(config_file)
+      raise 'File does not exist' unless File.exists? config_file
+      raise 'File is not readable' unless File.readable? config_file
+
+      content = nil
+
+      File.open(config_file, 'r') do |file|
+        content = file.read 
+      end
+
+      Config.parse content
+    end
+  
+    def self.parse(content)
+      raise 'Cannot process nil' if content.nil?
+
+      Treetop.load 'lib/rsync_config/parser/config_file'
+      parser = RsyncConfigFileParser.new
+      p = parser.parse content 
+
+      unless p.nil?   
+        return p.to_config.after_parse
+      else
+        raise RuntimeError, parser.failure_reason
+      end
+    end
+
+    def module(key)
+      raise ArgumentError if key.nil?
+      key = key.to_s if key.is_a? Symbol
+      key = key.strip
+      raise ArgumentError if key.length == 0
+
+      modules[key] ||= Module.new(self, key)
+
+      modules[key]
+    end
+
+    def to_s
+      to_config_file
+    end
+
+    def to_config_file
+      out = []
+      properties_to_s = properties_to_a.join("\n")
+      out << properties_to_s if properties_to_s.length > 0
+
+      modules.each do |key, mod|
+        out << mod.to_config_file
+      end
+
+      out.join "\n"
+    end
+
+    def write_to(file_path)
+      File.open(file_path, 'w') do |file|
+        file.write to_config_file
+      end
+
+      write_secrets_files
+    end
+
+    def module_names
+      modules.keys
+    end
+
+    def after_parse
+      batch_process_secrets_files :load_secrets_file
+    end
+
+    private
+
+    def modules
+      @modules ||= {}
+    end
+
+    def write_secrets_files
+      batch_process_secrets_files :write_secrets_file
+    end
+
+    def batch_process_secrets_files(method_name)
+      send method_name, self.[]('secrets file', true)
+
+      modules.each_value do |rmodule|
+        rmodule.send method_name, rmodule.[]('secrets file', true)
+      end
+
+      self
+    end
+
+  end
+
+end

data/lib/rsync_config/module.rb

@@ -0,0 +1,32 @@
+module RsyncConfig
+
+  class Module
+
+    include Propertiable
+    include UserManagement
+
+    # module properties
+    allow_properties :comment, :path, :use_chroot, :numeric_ids, :munge_symlinks, :charset
+    allow_properties :max_connections, :log_file, :syslog_facility, :max_verbosity, :lock_file
+    allow_properties :read_only, :write_only, :list, :uid, :gid, :fake_super, :filter, :exclude, :include
+    allow_properties :exclude_from, :include_from, :incoming_chmod, :outgoing_chmod, :auth_users
+    allow_properties :secrets_file, :strict_modes, :hosts_allow, :hosts_deny, :reverse_lookup
+    allow_properties :forward_lookup, :ignore_errors, :ignore_nonreadable, :transfer_logging
+    allow_properties :log_format, :timeout, :refuse_options, :dont_compress, 'pre-xfer exec', 'post-xfer exec'
+
+    def initialize(parent_config, name)
+      @parent_config = parent_config
+      @name = name
+    end
+
+    def to_s
+      to_config_file
+    end
+
+    def to_config_file
+      (["[#{@name}]"] + properties_to_a.map {|p| "    #{p}"}).join "\n"
+    end
+
+  end
+
+end

data/lib/rsync_config/parser/config_file.treetop

@@ -0,0 +1,98 @@
+require 'rsync_config/config'
+
+module RsyncConfig
+
+  grammar RsyncConfigFile
+
+    rule start 
+      global_section? module_section? EOF
+      {
+        attr_accessor :config, :active_module
+
+        def to_config
+          @config = ::RsyncConfig::Config.new
+          @active_module = nil
+
+          crawl self 
+
+          @config
+        end
+      }
+    end
+
+    rule global_section
+      ((comment / space? option?) EOL)+
+    end
+
+    rule module_section
+      (module_header module_body*)+
+    end
+
+    rule module_body
+      (comment / space? option?) EOL 
+    end
+
+    rule option
+      property space? '=' space? value space?
+      {
+        def action(top_node)
+          receiver = top_node.active_module.nil? ? top_node.config : top_node.active_module
+          receiver[property.text_value] = value.text_value
+
+          # interrupt subtree crawling
+          false
+        end
+      }
+    end
+
+    rule property
+      [^=\n]+ 
+    end
+
+    rule value
+      [^\n]* ('\\' space? EOL value)?
+      {
+        def value
+          text_value.gsub(/\\\s*\n/, ' ')
+        end
+      }
+    end
+
+    rule module_header
+      '[' module_label:([^/\]]+) ']' space?
+      {
+        def value
+          module_label.text_value.gsub /\s+/, ' '
+        end
+
+        def action(top_node)
+          top_node.active_module = top_node.config.module(module_label.text_value)
+
+          # interrupt subtree crawling
+          false
+        end
+      }
+    end
+
+    rule comment
+      space? '#' [^"\n"]*
+    end
+
+    rule space
+      [ \t]+
+    end
+
+    rule EOL
+      "\n"
+    end
+
+    rule EOF
+      !.
+    end
+
+    rule EOS
+      EOL / EOF
+    end
+  end
+
+end

data/lib/rsync_config/parser/node_extension.rb

@@ -0,0 +1,28 @@
+module RsyncConfig
+
+  module Node
+
+    module Crawlable
+
+      def crawl *args
+        continue = true
+        continue = action(*args) if respond_to? :action
+
+        return if !continue || elements.nil?
+
+        elements.each do |elt|
+          elt.crawl(*args)
+        end
+      end
+
+    end
+
+    class Treetop::Runtime::SyntaxNode
+
+      include ::RsyncConfig::Node::Crawlable
+
+    end
+
+  end
+
+end

data/lib/rsync_config/parser/secrets_file.treetop

@@ -0,0 +1,59 @@
+
+module RsyncConfig
+
+  grammar RsyncSecretsFile
+
+    rule start
+      lines
+      {
+        def to_hash
+          users = {}
+          crawl users
+
+          users
+        end
+      }
+    end
+
+    rule lines
+      line? (EOL+ lines)?
+    end
+
+    rule line
+      comment
+      / user_record
+      / whitespace+
+    end
+
+    rule comment
+      '#' [^\n]*
+    end
+
+    rule user_record
+      user:([^:]+) ':' password:([^\t\r\n\ ]+)
+      {
+        def action users
+          users[user_value] = password_value
+        end
+
+        def user_value
+          user.text_value
+        end
+
+        def password_value
+          password.text_value
+        end
+      }
+    end
+
+    rule whitespace
+      [ \t\r\n]
+    end
+
+    rule EOL
+      "\r\n" / "\n"
+    end
+
+  end
+end
+

data/lib/rsync_config/parser.rb

@@ -0,0 +1 @@
+require 'rsync_config/parser/node_extension'

data/lib/rsync_config/propertiable.rb

@@ -0,0 +1,68 @@
+module RsyncConfig
+
+  module Propertiable
+  
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def allow_properties *properties
+        properties.each do |property|
+          property = property.to_s if property.is_a? Symbol
+          property = property.downcase.strip.gsub(/_/, ' ')
+          allowed_properties.push property
+        end
+      end
+
+      def allowed_properties
+        @allowed_properties ||= []
+      end
+
+      def allowed_property? property
+        allowed_properties.include? property
+      end
+
+    end 
+    
+    def [](key, local_only = false)
+      key = sanitize_key(key)
+      return nil if key.nil? 
+
+      value = properties[key]
+      return @parent_config[key] if !local_only && value.nil? && @parent_config.respond_to?(:[])
+
+      value
+    end
+
+    def sanitize_key(key)
+      key = key.to_s unless key.is_a? String
+      key = key.strip.downcase
+      return nil if key.length == 0
+      return nil unless self.class.allowed_property? key
+      key
+    end
+
+    def []=(key, value)
+      key = sanitize_key(key)
+      if value.nil?
+        properties.delete key
+      else
+        properties[key] = value.to_s unless value.nil?
+      end
+    end
+
+    def properties_to_a
+      properties.map { |key, value| "#{key} = #{value}" }
+    end
+
+    private 
+    
+    def properties
+      @properties ||= {}
+    end
+    
+  end
+
+end

data/lib/rsync_config/user_management.rb

@@ -0,0 +1,86 @@
+module RsyncConfig
+
+  module UserManagement
+
+    def self.included base
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def parse_secrets_file(content)
+        raise 'Cannot process nil' if content.nil?
+
+        Treetop.load 'lib/rsync_config/parser/secrets_file'
+        parser = RsyncSecretsFileParser.new
+        p = parser.parse content
+
+        unless p.nil?
+          return p.to_hash
+        else
+          raise RuntimeError, parser.failure_reason
+        end
+      end
+
+    end
+
+    def users
+      return @parent_config.users if @parent_config && @users.nil?
+      local_users
+    end
+
+    def local_users
+      @users ||= {}
+    end
+
+    def user? identifier
+      users.include? identifier
+    end
+
+    def users= (users_list)
+      @users = users_list if users_list.is_a?(Hash) || users_list.nil?
+    end
+
+    def local_user_list
+      # we need to output only what is related to this specific node
+      local_users.keys.map do |user|
+        "#{user}:#{local_users[user]}"
+      end 
+    end
+
+    def write_secrets_file(file)
+      return if file.nil?
+      raise "Cannot write secrets file #{file}" if File.exists?(file) && ! File.writable?(file)
+      raise "Cannot create secrets file #{file}" if !File.exist?(file) && ! ( Dir.exists?(File.dirname(file)) && File.writable?(File.dirname(file)))
+
+      File.open(file, 'w') do |file|
+        file.write local_user_list.join "\n"
+      end
+
+      correct_file_permissions file
+    end
+
+    def load_secrets_file(file)
+      # fails silently if no parameter is found OR the file does not exist on disk
+      return if file.nil? || !(File.exist? file)
+
+      # fails is the file exists but cannot be read, since it's suspicious
+      raise "Cannot load secrets file #{file}" unless File.readable?(file)
+
+      File.open(file, 'r') do |file|
+        self.users = self.class.parse_secrets_file(file.read)
+      end
+    end
+
+    private 
+
+    def correct_file_permissions(file)
+      if File.world_readable?(file) || File.world_writable?(file)
+        # reuse existing permissions but remove everything from world
+        File.chmod (File.stat(file).mode & 0770), file
+      end
+    end
+
+  end
+
+end

data/lib/rsync_config/version.rb

@@ -0,0 +1,3 @@
+module RsyncConfig
+  VERSION = "0.1.0"
+end

data/lib/rsync_config.rb

@@ -0,0 +1,20 @@
+require 'polyglot'
+require 'treetop'
+require 'rsync_config/version'
+require 'rsync_config/parser'
+require 'rsync_config/propertiable'
+require 'rsync_config/user_management'
+require 'rsync_config/module'
+require 'rsync_config/config'
+
+module RsyncConfig
+  
+  def self.load_file(config_file)
+    Config.load_file config_file
+  end
+
+  def self.parse(content)
+    Config.parse content
+  end
+
+end

data/rsync_config.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rsync_config/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rsync_config"
+  spec.version       = RsyncConfig::VERSION
+  spec.authors       = ["Guillaume Bodi"]
+  spec.email         = ["bodi.giyomu@gmail.com"]
+  spec.description   = %q{Utility gem to manage rsyncd config files}
+  spec.summary       = %q{Utility gem to manage rsyncd config files}
+  spec.homepage      = ""
+  spec.license       = "GPLv3"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "test-unit"
+	
+	spec.add_dependency 'treetop', '~>1.4.14'
+end

data/test/etc/rsyncd.conf

@@ -0,0 +1,10 @@
+uid = nobody
+gid = nobody
+use chroot = no
+max connections = 4
+syslog facility = local5
+pid file = /run/rsyncd.pid
+
+[ftp]
+        path = /srv/ftp
+        comment = ftp area

data/test/etc/rsyncd_with_secrets.conf

@@ -0,0 +1,12 @@
+uid = nobody
+gid = nobody
+use chroot = no
+max connections = 4
+syslog facility = local5
+pid file = /run/rsyncd.pid
+secrets file = test/etc/secrets_top.conf
+
+[ftp]
+    path = /srv/ftp
+    comment = ftp area
+    secrets file = test/etc/secrets_ftp.conf

data/test/etc/secrets_ftp.conf

@@ -0,0 +1,4 @@
+john:lennon
+paul:mccartney
+georges:something
+ringo:starr

data/test/etc/secrets_top.conf

@@ -0,0 +1,2 @@
+john:lennon
+bob:bidwell

data/test/test_rsync_config.rb

@@ -0,0 +1,233 @@
+require 'test-unit'
+require 'rsync_config'
+
+class RsyncConfigTest < Test::Unit::TestCase
+
+  TEST_INPUT_FILE = File.join(__dir__, 'etc', 'rsyncd.conf')
+
+  TEST_INPUT_FILE_WITH_SECRETS = File.join(__dir__, 'etc', 'rsyncd_with_secrets.conf')
+
+  TEST_OUTPUT_FILE = File.join(__dir__, 'etc', 'out', 'rsyncd.conf')
+
+  TEST_SECRETS_FILE = File.join(__dir__, 'etc', 'out', 'secrets.conf')
+
+  def teardown
+    File.delete TEST_OUTPUT_FILE if File.exists? TEST_OUTPUT_FILE
+    File.delete TEST_SECRETS_FILE if File.exists? TEST_SECRETS_FILE
+  end
+
+  def make_new_config
+    RsyncConfig::Config.new
+  end
+
+  def make_simple_config
+    RsyncConfig.load_file TEST_INPUT_FILE
+  end
+
+  def make_secrets_config
+    RsyncConfig.load_file TEST_INPUT_FILE_WITH_SECRETS
+  end
+
+  def test_load_missing_file
+    assert_raise RuntimeError, 'Did not throw an error for missing file'  do
+      RsyncConfig.load_file 'idontexist.conf'
+    end
+  end
+
+  def test_load_file_does_not_crash
+    config = nil
+    assert_nothing_raised RuntimeError do
+      config = make_simple_config
+    end
+
+    assert_equal config.class, RsyncConfig::Config, 'Did not return a config object' end
+
+  def test_accessing_missing_properties_returns_nil
+    config = make_new_config
+
+    assert_nil config[:i_dont_exist]
+  end
+
+  def test_accessing_a_property_returns_a_string
+    config = make_new_config
+    config[:uid] = 'nobody'
+
+    assert_equal 'nobody', config[:uid]
+  end
+
+  def test_one_module_output
+    config = make_new_config
+    ftp_module = config.module :ftp
+    ftp_module[:path] = 'local'
+    expected = <<EOS
+[ftp]
+    path = local
+EOS
+
+    assert_equal expected.strip, config.to_config_file
+  end
+
+  def test_module_listing
+    config = make_new_config
+    config.module :ftp
+    config.module :smb
+    config.module :something
+
+    assert_equal ['ftp', 'smb', 'something'], config.module_names
+  end
+
+  def test_easy_accessor_complete
+    config = make_new_config
+    config[:uid] = 'nut'
+    config[:gid] = 'kiwi'
+    config[:uid] = config[:gid]
+
+    assert_equal 'kiwi', config[:uid]
+    assert_equal config[:gid], config[:uid]
+  end
+
+  def test_remove_property
+    config = make_new_config
+    config[:uid] = 'true'
+    config[:comment] = 'false'
+
+    # remove the comment config
+    config[:comment] = nil
+    expected = <<EOS
+uid = true
+EOS
+    assert_equal expected.strip, config.to_s
+  end
+
+  def test_module_inherits_config
+    config = make_new_config
+    config[:uid] = 'true'
+    ftp_module = config.module :ftp
+
+    assert_equal 'true', ftp_module[:uid]
+  end
+
+  def test_global_users_accessor_exists
+    config = make_new_config
+
+    assert_not_nil config.users
+  end
+
+  def test_global_users_assignment
+    config = make_new_config
+    config.users = {'john' => 'password'}
+
+    assert_true config.user?('john')
+  end
+
+  def test_global_user_existence
+    config = make_new_config
+    config.users = {'john' => 'password'}
+
+    assert_true config.user?('john')
+  end
+
+  def test_global_user_inexistence
+    config = make_new_config
+
+    assert_false config.user?('georges')
+  end
+
+  def test_module_user_existence
+    config = make_new_config
+    ftp_module = config.module :ftp
+    ftp_module.users = {'john' => 'password'}
+
+    assert_true ftp_module.user? 'john'
+    assert_false ftp_module.user? 'george'
+  end
+
+  def test_module_user_inexistence
+    config = make_new_config
+    ftp_module = config.module :ftp
+
+    assert_false ftp_module.user? 'george'
+  end
+
+  def test_module_user_inheritance
+    config = make_new_config
+    config.users = {'john' => 'password'}
+    ftp_module = config.module :ftp
+    ftp_module.users = {'george' => 'password'}
+
+    assert_false ftp_module.user? 'john'
+    assert_true ftp_module.user? 'george'
+  end
+
+  def test_write_to_file_succeeds
+    config = make_new_config
+    config.write_to TEST_OUTPUT_FILE
+
+    assert_true File.exists? TEST_OUTPUT_FILE
+  end
+
+  def test_write_to_file_has_correct_content
+    config = make_new_config
+    config[:uid] = 'test'
+
+    config.write_to TEST_OUTPUT_FILE
+    expected = <<EOL
+uid = test
+EOL
+
+    assert_equal expected.strip, File.read(TEST_OUTPUT_FILE).strip
+  end
+
+  def test_write_to_secrets_file_succeeds
+    config = make_simple_config
+    config['secrets file'] = TEST_SECRETS_FILE
+    config.users['john'] = 'doe'
+
+    config.write_to TEST_OUTPUT_FILE
+
+    assert_true File.exists? TEST_SECRETS_FILE
+  end
+
+  def test_write_to_secrets_file_has_correct_permissions
+    config = make_new_config
+    config['secrets file'] = TEST_SECRETS_FILE
+    config.users['john'] = 'doe'
+
+    config.write_to TEST_OUTPUT_FILE
+
+    assert_nil File.world_readable? TEST_SECRETS_FILE
+    assert_nil File.world_writable? TEST_SECRETS_FILE
+  end
+
+  def test_write_correct_content_to_secrets_file
+    config = make_new_config
+    config['secrets file'] = TEST_SECRETS_FILE
+    config.users['john'] = 'doe'
+
+    config.write_to TEST_OUTPUT_FILE
+
+    secrets_expected = <<EOL
+john:doe
+EOL
+    assert_equal secrets_expected.strip, File.read(TEST_SECRETS_FILE).strip
+  end
+
+  def test_module_secrets_user_exists
+    config = make_secrets_config
+
+    assert_true config.module(:ftp).user? 'john'
+  end
+
+  def test_global_secrets_user_exists
+    config = make_secrets_config
+
+    assert_true config.user? 'bob'
+  end
+
+  def test_module_overriden_secrets_does_not_include_global_users
+    config = make_secrets_config
+
+    assert_false config.module(:ftp).user? 'bob'
+  end
+
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: rsync_config
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Guillaume Bodi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.14
+description: Utility gem to manage rsyncd config files
+email:
+- bodi.giyomu@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rsync_config.rb
+- lib/rsync_config/config.rb
+- lib/rsync_config/module.rb
+- lib/rsync_config/parser.rb
+- lib/rsync_config/parser/config_file.treetop
+- lib/rsync_config/parser/node_extension.rb
+- lib/rsync_config/parser/secrets_file.treetop
+- lib/rsync_config/propertiable.rb
+- lib/rsync_config/user_management.rb
+- lib/rsync_config/version.rb
+- rsync_config.gemspec
+- test/etc/out/.keep
+- test/etc/rsyncd.conf
+- test/etc/rsyncd_with_secrets.conf
+- test/etc/secrets_ftp.conf
+- test/etc/secrets_top.conf
+- test/test_rsync_config.rb
+homepage: ''
+licenses:
+- GPLv3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: Utility gem to manage rsyncd config files
+test_files:
+- test/etc/out/.keep
+- test/etc/rsyncd.conf
+- test/etc/rsyncd_with_secrets.conf
+- test/etc/secrets_ftp.conf
+- test/etc/secrets_top.conf
+- test/test_rsync_config.rb