dslimple 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d3524b1943dd7ea604e2dc0405d806500a4c5c3f
+  data.tar.gz: bbd8df2e9fa8193f6fa6941784503115335a0e9b
+SHA512:
+  metadata.gz: b50b823159fdbcb21b32c6db9723a0728f951affc184e354b3e786d48098042c552ce1dbf74c150f93db37aedb51d1803b7c03d6d51f8163d91b0871017b83da
+  data.tar.gz: 4f1ea991bdbe56a6a6e8c58ccc444c4e22bacff0b0cc4da2f0a8796e49e897383720a2a0565414d50dcabb5908637b77a53901a1f63d73755c4522273b8a40da

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Domainfile
+/domainfiles

data/.rubocop.yml

@@ -0,0 +1,28 @@
+AllCops:
+  Include:
+    - "*.gemspec"
+  Exclude:
+    - "vendor/**/*"
+    - "db/schema.rb"
+  DisplayCopNames: true
+
+Style/Alias:
+  EnforcedStyle: prefer_alias_method
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+
+Style/CaseEquality:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 160
+
+Metrics/MethodLength:
+  Max: 20
+
+Metrics/AbcSize:
+  Max: 25

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Sho Kusano
+
+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,157 @@
+# DSLimple
+
+__DSLimple__ is a tool to manage [DNSimple](https://dnsimple.com/).
+
+It defines the state of DNSimple using DSL, and updates DNSimple according to DSL.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dslimple'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dslimple
+
+## Usage
+
+```shell
+export DLSIMPLE_EMAIL="..."
+export DLSIMPLE_API_TOKEN="..."
+dslimple export -f Domainfile
+vi Domainfile
+dslimple apply --dry-run -f Domainfile
+dslimple apply --yes -f Domainfile
+```
+
+### Help
+
+```
+$ dslimple help
+Commands:
+  dslimple apply           # Apply domain specifications
+  dslimple export          # Export domain specifications
+  dslimple help [COMMAND]  # Describe available commands or one specific command
+
+Options:
+  -e, [--email=EMAIL]                 # Your E-Mail address
+  -t, [--api-token=API_TOKEN]         # Your API token
+  -dt, [--domain-token=DOMAIN_TOKEN]  # Your Domain API token
+      [--sandbox], [--no-sandbox]     # Use sandbox API(at sandbox.dnsimple.com)
+                                      # Default: true
+      [--debug], [--no-debug]
+```
+
+#### help apply
+
+```
+$ dslimple help apply
+Usage:
+  dslimple apply
+
+Options:
+  -o, [--only=one two three]                 # Specify domains for apply
+  -d, [--dry-run], [--no-dry-run]
+  -f, [--file=FILE]                          # Source Domainfile path
+                                             # Default: Domainfile
+      [--addition], [--no-addition]          # Add specified records
+                                             # Default: true
+      [--modification], [--no-modification]  # Modify specified records
+                                             # Default: true
+      [--deletion], [--no-deletion]          # Delete unspecified records
+                                             # Default: true
+  -y, [--yes], [--no-yes]                    # Do not confirm on before apply
+  -e, [--email=EMAIL]                        # Your E-Mail address
+  -t, [--api-token=API_TOKEN]                # Your API token
+  -dt, [--domain-token=DOMAIN_TOKEN]         # Your Domain API token
+      [--sandbox], [--no-sandbox]            # Use sandbox API(at sandbox.dnsimple.com)
+                                             # Default: true
+      [--debug], [--no-debug]
+
+Apply domain specifications
+```
+
+#### help export
+
+```
+$ dslimple help export
+Usage:
+  dslimple export
+
+Options:
+  -o, [--only=one two three]             # Specify domains for export
+  -f, [--file=FILE]                      # Export Domainfile path
+                                         # Default: Domainfile
+  -d, [--dir=DIR]                        # Export directory path for split
+                                         # Default: ./domainfiles
+  -s, [--split], [--no-split]            # Export with split by domains
+  -m, [--modeline], [--no-modeline]      # Export with modeline for Vim
+      [--soa-and-ns], [--no-soa-and-ns]  # Export without SOA and NS records
+  -e, [--email=EMAIL]                    # Your E-Mail address
+  -t, [--api-token=API_TOKEN]            # Your API token
+  -dt, [--domain-token=DOMAIN_TOKEN]     # Your Domain API token
+      [--sandbox], [--no-sandbox]        # Use sandbox API(at sandbox.dnsimple.com)
+                                         # Default: true
+      [--debug], [--no-debug]
+
+Export domain specifications
+```
+
+## Domainfile Examples
+
+### Basic
+
+The following defines are all the same meaning
+
+```ruby
+domain "example.com" do
+  a_record ttl: 3600 do
+    "0.0.0.0"
+  end
+
+  record type: :a, ttl: 3600 do
+    "0.0.0.0"
+  end
+
+  a_record do
+    ttl 3600
+    content "0.0.0.0"
+  end
+end
+```
+
+### Dynamic
+
+DSLimple's DSL works on ruby.
+
+```ruby
+require 'open-uri'
+require 'json'
+
+domain "example.internal" do
+  JSON.parse(open('http://my.internal.service/records.json', &:read)).each do |record_data|
+    recored record_data['name'], record_data['options'] { record_data['content'] }
+  end
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/zeny-io/dslimple.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Inspired by
+
+- [roadworker](https://github.com/winebarrel/roadworker)
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dslimple"
+
+# 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/dslimple.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dslimple/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dslimple'
+  spec.version       = Dslimple::VERSION
+  spec.authors       = ['Sho Kusano']
+  spec.email         = ['sho-kusano@zeny.io']
+
+  spec.summary       = 'DSLimple is a tool to manage DNSimple.'
+  spec.description   = 'DSLimple is a tool to manage DNSimple. It defines the state of DNSimple using DSL, and updates DNSimple according to DSL.'
+  spec.homepage      = 'https://github.com/zeny-io/dslimple'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rubocop'
+
+  spec.add_dependency 'dnsimple', '~> 2.1'
+  spec.add_dependency 'thor', '~> 0.19'
+end

data/exe/dslimple

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'dslimple/cli'
+Dslimple::CLI.start(ARGV)

data/lib/dslimple/applier.rb

@@ -0,0 +1,68 @@
+require 'dslimple'
+require 'pp'
+
+class Dslimple::Applier
+  OPERATION_COLORS = {
+    addition: :green,
+    modification: :yellow,
+    deletion: :red
+  }
+
+  attr_reader :api_client, :shell, :options
+
+  def initialize(api_client, shell, options = {})
+    @api_client = api_client
+    @shell = shell
+    @options = options
+  end
+
+  def execute
+    dsl = Dslimple::DSL.new(options[:file], options)
+
+    dsl.execute
+
+    expected_domains = dsl.transform
+    expected_domains.select! { |domain| options[:only].include?(domain.name) } if options[:only].any?
+
+    @buildler = Dslimple::QueryBuilder.new(fetch_domains, expected_domains)
+    @buildler.execute
+    queries = @buildler.filtered_queries(options)
+
+    if queries.empty?
+      shell.say('No Changes', :bold)
+      return
+    end
+
+    show_plan(queries)
+
+    return if options[:dry_run] || !(options[:yes] || shell.yes?("Apply #{queries.size} changes. OK?(y/n) >"))
+
+    apply(queries)
+  end
+
+  def fetch_domains
+    domains = api_client.domains.list.map { |domain| Dslimple::Domain.new(domain.name, api_client, id: domain.id) }
+    domains.each(&:fetch_records!)
+    domains.select! { |domain| options[:only].include?(domain.name) } if options[:only].any?
+    domains
+  end
+
+  def show_plan(queries)
+    shell.say("Changes", :bold)
+    queries.each do |query|
+      show_query(query)
+    end
+  end
+
+  def apply(queries)
+    shell.say('Apply', :bold)
+    queries.each do |query|
+      show_query(query)
+      query.execute(api_client)
+    end
+  end
+
+  def show_query(query)
+    shell.say("#{shell.set_color(query.operation.to_s[0..2], OPERATION_COLORS[query.operation])} #{query.to_s}")
+  end
+end

data/lib/dslimple/cli.rb

@@ -0,0 +1,81 @@
+require 'thor'
+require 'dnsimple'
+require 'json'
+require 'dslimple'
+
+class Dslimple::CLI < Thor
+  include Thor::Actions
+
+  SANDBOX_API_ENDPOINT = 'https://api.sandbox.dnsimple.com'.freeze
+  USER_AGENT = "DSLimple: Simple CLI DNSimple client(v#{Dslimple::VERSION})".freeze
+
+  class_option :email, type: :string, aliases: %w(-e), desc: 'Your E-Mail address'
+  class_option :api_token, type: :string, aliases: %w(-t), desc: 'Your API token'
+  class_option :domain_token, type: :string, aliases: %w(-dt), desc: 'Your Domain API token'
+  class_option :sandbox, type: :boolean, default: ENV['DLSIMPLE_ENV'] == 'test', desc: 'Use sandbox API(at sandbox.dnsimple.com)'
+  class_option :debug, type: :boolean, default: false
+
+  desc 'export', 'Export domain specifications'
+  method_option :only, type: :array, default: [], aliases: %w(-o), desc: 'Specify domains for export'
+  method_option :file, type: :string, default: 'Domainfile', aliases: %w(-f), desc: 'Export Domainfile path'
+  method_option :dir, type: :string, default: './domainfiles', aliases: %w(-d), desc: 'Export directory path for split'
+  method_option :split, type: :boolean, default: false, aliases: %w(-s), desc: 'Export with split by domains'
+  method_option :modeline, type: :boolean, default: false, aliases: %w(-m), desc: 'Export with modeline for Vim'
+  method_option :soa_and_ns, type: :boolean, default: false, desc: 'Export without SOA and NS records'
+  def export
+    exporter = Dslimple::Exporter.new(api_client, options)
+
+    exporter.execute
+  rescue => e
+    rescue_from(e)
+  end
+
+  desc 'apply', 'Apply domain specifications'
+  method_option :only, type: :array, default: [], aliases: %w(-o), desc: 'Specify domains for apply'
+  method_option :dry_run, type: :boolean, default: false, aliases: %w(-d)
+  method_option :file, type: :string, default: 'Domainfile', aliases: %w(-f), desc: 'Source Domainfile path'
+  method_option :addition, type: :boolean, default: true, desc: 'Add specified records'
+  method_option :modification, type: :boolean, default: true, desc: 'Modify specified records'
+  method_option :deletion, type: :boolean, default: true, desc: 'Delete unspecified records'
+  method_option :yes, type: :boolean, default: false, aliases: %w(-y), desc: 'Do not confirm on before apply'
+  def apply
+    applier = Dslimple::Applier.new(api_client, self, options)
+
+    applier.execute
+  rescue => e
+    rescue_from(e)
+  rescue Dslimple::DSL::Error => e
+    rescue_from(e)
+  end
+
+  private
+
+  def api_client
+    @api_client ||= Dnsimple::Client.new(
+      username: options[:email] || ENV['DLSIMPLE_EMAIL'],
+      api_token: options[:api_token] || ENV['DLSIMPLE_API_TOKEN'],
+      domain_api_token: options[:domain_token] || ENV['DLSIMPLE_DOMAIN_TOKEN'],
+      api_endpoint: options[:sandbox] ? SANDBOX_API_ENDPOINT : nil,
+      user_agent: USER_AGENT
+    )
+  end
+
+  def rescue_from(e)
+    raise e if options[:debug]
+
+    case e
+    when Dnsimple::AuthenticationError
+      error(set_color(e.message, :red, :bold))
+    when Dnsimple::RequestError
+      error(set_color("#{e.message}: #{JSON.parse(e.response.body)['message']}", :yellow, :bold))
+    when Dslimple::DSL::Error
+      error(set_color(e.message, :yellow, :bold))
+    else
+      error(set_color("#{e.class}: #{e.message}", :red, :bold))
+    end
+    e.backtrace.each do |bt|
+      say("  #{set_color('from', :green)} #{bt}")
+    end
+    exit 1
+  end
+end

data/lib/dslimple/domain.rb

@@ -0,0 +1,48 @@
+require 'dslimple'
+
+class Dslimple::Domain
+  attr_reader :name, :id
+  attr_accessor :api_client, :records
+
+  def initialize(name, api_client, options = {})
+    @name = name
+    @id = options[:id]
+    @api_client = api_client
+    @records = []
+  end
+
+  def escaped_name
+    Dslimple.escape_single_quote(name)
+  end
+
+  def records_without_soa_ns
+    records.select { |record| record.type != :soa && record.type != :ns }
+  end
+
+  def fetch_records
+    api_client.domains.records(name).map do |record|
+      Dslimple::Record.new(self, record.record_type, record.name, record.content, ttl: record.ttl, priority: record.priority, id: record.id)
+    end
+  end
+
+  def fetch_records!
+    @records = fetch_records
+    cleanup_records!
+  end
+
+  def cleanup_records!
+    @records = Dslimple::Record.cleanup_records(records)
+  end
+
+  def ==(other)
+    other.is_a?(Dslimple::Domain) && other.name == name
+  end
+  alias_method :eql, :==
+
+  def to_dsl(options = {})
+    <<"EOD"
+domain '#{escaped_name}' do
+#{(options[:soa_and_ns] ? records : records_without_soa_ns).map(&:to_dsl).join("\n")}end
+EOD
+  end
+end

data/lib/dslimple/dsl/domain.rb

@@ -0,0 +1,29 @@
+require 'dslimple/dsl'
+
+class Dslimple::DSL::Domain
+  attr_reader :name, :records
+
+  def initialize(name, &block)
+    @name = name
+    @records = []
+
+    instance_eval(&block)
+  end
+
+  def record(name = {}, options = {}, &block)
+    if name.is_a?(Hash)
+      options = options.merge(name)
+      name = ''
+    end
+
+    @records << Dslimple::DSL::Record.new(name, options, &block)
+  end
+
+  Dslimple::Record::RECORD_TYPES.each do |type|
+    class_eval(<<-EOC)
+      def #{type}_record(name = {}, options = {}, &block)
+        record(name, options.merge(type: :#{type}), &block)
+      end
+    EOC
+  end
+end

data/lib/dslimple/dsl/error.rb

@@ -0,0 +1,4 @@
+require 'dslimple/dsl'
+
+class Dslimple::DSL::Error < Exception
+end

data/lib/dslimple/dsl/record.rb

@@ -0,0 +1,25 @@
+require 'dslimple/dsl'
+
+class Dslimple::DSL::Record
+  attr_reader :name, :content, :options
+
+  def initialize(name, options = {}, &block)
+    @name = name
+    @options = options
+
+    returned_content = instance_eval(&block)
+    @content ||= returned_content
+  end
+
+  def priority(n)
+    @options[:priority] = n.to_s.to_i
+  end
+
+  def ttl(n)
+    @options[:ttl] = n.to_s.to_i
+  end
+
+  def content(c = nil)
+    c ? @content = c : @content
+  end
+end

data/lib/dslimple/dsl.rb

@@ -0,0 +1,65 @@
+require 'pathname'
+require 'dslimple'
+
+class Dslimple::DSL
+  def initialize(file, context = {})
+    @file = Pathname.new(file)
+    @dir = @file.dirname
+    @domains = []
+    @files = []
+
+    @context = context
+  end
+
+  def execute
+    evaluate(@file)
+  end
+
+  def require(path)
+    if @dir.join(path).exist?
+      evaluate(@dir.join(path))
+    elsif @dir.join("#{path}.rb").exist?
+      evaluate(@dir.join("#{path}.rb"))
+    else
+      Kernel.require(path)
+    end
+  end
+
+  def evaluate(file)
+    @files << file.to_s
+    instance_eval(File.read(file), file.to_s)
+  rescue ScriptError => e
+    raise Dslimple::DSL::Error, "#{e.class}: #{e.message}", cleanup_backtrace(e.backtrace)
+  rescue StandardError => e
+    raise Dslimple::DSL::Error, "#{e.class}: #{e.message}", cleanup_backtrace(e.backtrace)
+  end
+
+  def domain(name, &block)
+    @domains << Dslimple::DSL::Domain.new(name, &block)
+  end
+
+  def transform
+    @domains.map do |domain|
+      Dslimple::Domain.new(domain.name, nil).tap do |model|
+        model.records = domain.records.map do |record|
+          Dslimple::Record.new(model, record.options[:type], record.name, record.content, record.options)
+        end
+      end
+    end
+  end
+
+  private
+
+  def cleanup_backtrace(backtrace)
+    return backtrace if @context[:debug]
+
+    backtrace.select do |bt|
+      path = bt.split(':')[0..-3].join(':')
+      @files.include?(path)
+    end
+  end
+end
+
+require 'dslimple/dsl/domain'
+require 'dslimple/dsl/record'
+require 'dslimple/dsl/error'

data/lib/dslimple/exporter.rb

@@ -0,0 +1,55 @@
+require 'pathname'
+require 'dslimple'
+
+class Dslimple::Exporter
+  attr_reader :api_client, :options, :domains
+
+  def initialize(api_client, options)
+    @api_client = api_client
+    @options = options
+    @domains = []
+  end
+
+  def execute
+    @domains = fetch_domains
+
+    if options[:split] && options[:dir]
+      split_export(options[:dir], options[:file])
+    else
+      export(options[:file], domains)
+    end
+  end
+
+  def fetch_domains
+    domains = api_client.domains.list.map { |domain| Dslimple::Domain.new(domain.name, api_client) }
+    domains.each(&:fetch_records!)
+    domains.select! { |domain| options[:only].include?(domain.name) } unless options[:only].empty?
+    domains
+  end
+
+  def export(file, export_domains)
+    File.open(file.to_s, 'w') do |fd|
+      write_modeline(fd)
+      fd.puts export_domains.map { |domain| domain.to_dsl(options) }.join("\n")
+    end
+  end
+
+  def split_export(dir, file)
+    dir = Pathname.new(dir)
+    file = Pathname.new(file)
+    Dir.mkdir(dir.to_s) unless dir.directory?
+
+    File.open(file.to_s, 'w') do |fd|
+      write_modeline(fd)
+      domains.each do |domain|
+        domainfile = dir.join(domain.name)
+        export(domainfile, [domain])
+        fd.puts "require '#{domainfile.relative_path_from(file.dirname)}'"
+      end
+    end
+  end
+
+  def write_modeline(fd)
+    fd << "# -*- mode: ruby -*-\n# vi: set ft=ruby :\n\n" if options[:modeline]
+  end
+end

data/lib/dslimple/query.rb

@@ -0,0 +1,60 @@
+require 'dslimple'
+
+class Dslimple::Query
+  attr_reader :operation, :target, :domain, :params
+
+  def initialize(operation, target, domain, params = {})
+    @operation = operation
+    @target = target
+    @domain = domain
+    @params = params
+  end
+
+  %i(addition modification deletion).each do |operation|
+    class_eval(<<-EOC)
+    def #{operation}?
+      operation == :#{operation}
+    end
+    EOC
+  end
+
+  def to_s
+    if target == :domain
+      "#{domain.name}"
+    else
+      %(#{params[:record_type].to_s.rjust(5)} #{params[:name].to_s.rjust(10)}.#{domain.name} (#{record_options.join(', ')}) "#{params[:content]}")
+    end
+  end
+
+  def record_options
+    options = []
+    params.each_pair do |k, v|
+      options << "#{k}: #{v}" if %i(ttl prio).include?(k) && v
+    end
+    options
+  end
+
+  def execute(api_client)
+    __send__("execute_#{target}", api_client)
+  end
+
+  def execute_domain(api_client)
+    case operation
+    when :addition
+      api_client.domains.create(name: domain.name)
+    when :deletion
+      api_client.domains.delete(domain.name)
+    end
+  end
+
+  def execute_record(api_client)
+    case operation
+    when :addition
+      api_client.domains.create_record(domain.name, params)
+    when :modification
+      api_client.domains.update_record(domain.name, params[:id], params)
+    when :deletion
+      api_client.domains.delete_record(domain.name, params[:id])
+    end
+  end
+end

data/lib/dslimple/query_builder.rb

@@ -0,0 +1,86 @@
+require 'dslimple'
+
+class Dslimple::QueryBuilder
+  attr_reader :queries
+  attr_reader :expected_domains, :current_domains
+  attr_reader :append_records, :change_records, :delete_records
+
+  def initialize(current_domains, expected_domains)
+    @current_domains = Hash[*current_domains.map { |domain| [domain.name, domain] }.flatten]
+    @expected_domains = Hash[*expected_domains.map { |domain| [domain.name, domain] }.flatten]
+  end
+
+  def append_domains
+    @append_domains ||= expected_domains.values.reject { |domain| current_domains.key?(domain.name) }
+  end
+
+  def delete_domains
+    @delete_domains ||= current_domains.values.reject { |domain| expected_domains.key?(domain.name) }
+  end
+
+  def execute
+    @append_records = append_domains.map(&:records_without_soa_ns).flatten
+    @change_records = []
+    @delete_records = delete_domains.map(&:records_without_soa_ns).flatten
+
+    expected_domains.each_pair do |name, domain|
+      execute_records(name, domain)
+    end
+
+    build_queries
+  end
+
+  def execute_records(domain_name, domain)
+    current_domain = current_domains[domain_name]
+    return unless current_domain
+
+    current_records = current_domain.records_without_soa_ns.dup
+    domain.records_without_soa_ns.each do |record|
+      at = current_records.index { |current| current == record }
+      current_record = at ? current_records.slice!(at) : nil
+      like_record = current_records.find { |current| current === record }
+
+      if !like_record && !current_record
+        @append_records << record
+      elsif like_record
+        @change_records << [like_record, record]
+        current_records.delete(like_record)
+      end
+    end
+    @delete_records.concat(current_records)
+  end
+
+  def build_queries
+    @queries = []
+
+    append_domains.each do |domain|
+      @queries << Dslimple::Query.new(:addition, :domain, domain)
+    end
+
+    append_records.each do |record|
+      @queries << Dslimple::Query.new(:addition, :record, record.domain, record.to_params)
+    end
+
+    change_records.each do |old, new|
+      @queries << Dslimple::Query.new(:modification, :record, new.domain, new.to_params.merge(id: old.id))
+    end
+
+    delete_records.each do |record|
+      @queries << Dslimple::Query.new(:deletion, :record, record.domain, record.to_params)
+    end
+
+    delete_domains.each do |domain|
+      @queries << Dslimple::Query.new(:deletion, :domain, domain)
+    end
+
+    @queries
+  end
+
+  def filtered_queries(options)
+    queries.select do |query|
+      (query.addition? && options[:addition]) ||
+        (query.modification? && options[:modification]) ||
+        (query.deletion? && options[:deletion])
+    end
+  end
+end

data/lib/dslimple/record.rb

@@ -0,0 +1,114 @@
+require 'dslimple'
+
+class Dslimple::Record
+  RECORD_TYPES = %i(a alias cname mx spf url txt ns srv naptr ptr aaaa sshfp hinfo pool).freeze
+  ALIAS_PREFIX = /\AALIAS for /
+  SPF_PREFIX = /\Av=spf1 /
+
+  attr_reader :domain, :type, :name, :id, :ttl, :priority, :content
+
+  def self.cleanup_records(records)
+    records = records.dup
+    alias_records = records.select(&:alias?)
+    spf_records = records.select(&:spf?)
+    txt_records = records.select { |record| record.like_spf? || record.like_alias? }
+
+    txt_records.each do |record|
+      reject = record.like_spf? ? spf_records.any? { |r| record.eql_spf?(r) } : alias_records.any? { |r| record.eql_alias?(r) }
+
+      records.delete(record) if reject
+    end
+
+    records
+  end
+
+  RECORD_TYPES.each do |type|
+    class_eval(<<-EOC)
+      def #{type}?
+        type == :#{type}
+      end
+    EOC
+  end
+
+  def initialize(domain, type, name, content, options = {})
+    @domain = domain
+    @type = type.to_s.downcase.to_sym
+    @name = name
+    @content = content
+    @ttl = options[:ttl]
+    @priority = options[:priority]
+    @id = options[:id]
+  end
+
+  def escaped_name
+    Dslimple.escape_single_quote(name)
+  end
+
+  def escaped_content
+    Dslimple.escape_single_quote(content)
+  end
+
+  def like_spf?
+    txt? && content.match(SPF_PREFIX)
+  end
+
+  def like_alias?
+    txt? && content.match(ALIAS_PREFIX)
+  end
+
+  def eql_spf?(spf_record)
+    spf_record.ttl == ttl && spf_record.content == content
+  end
+
+  def eql_alias?(alias_record)
+    alias_record.ttl == ttl && content == "ALIAS for #{alias_record.content}"
+  end
+
+  def ==(other)
+    other.is_a?(Dslimple::Record) && other.domain == domain && other.hash == hash
+  end
+  alias_method :eql, :==
+
+  def ===(other)
+    other.is_a?(Dslimple::Record) && other.domain == domain && other.rough_hash == rough_hash
+  end
+
+  def hash
+    "#{type}:#{name}:#{content}:#{ttl}:#{priority}"
+  end
+
+  def rough_hash
+    "#{type}:#{name}:#{content}"
+  end
+
+  def to_dsl_options
+    options = []
+    options << "'#{escaped_name}'" unless escaped_name.empty?
+    options << "ttl: #{ttl}" if ttl
+    options << "priority: #{priority}" if priority
+    options.join(', ')
+  end
+
+  def to_dsl
+    <<"EOD"
+  #{type}_record #{to_dsl_options} do
+    '#{escaped_content}'
+  end
+EOD
+  end
+
+  def to_params
+    {
+      id: id,
+      record_type: type.to_s.upcase,
+      name: name,
+      content: content,
+      ttl: ttl,
+      prio: priority
+    }
+  end
+
+  def inspect
+    "<Dslimple::Record #{type.to_s.upcase} #{name}: #{content}>"
+  end
+end

data/lib/dslimple/version.rb

@@ -0,0 +1,3 @@
+module Dslimple
+  VERSION = '1.0.0'.freeze
+end

data/lib/dslimple.rb

@@ -0,0 +1,18 @@
+require 'dslimple/version'
+require 'dslimple/domain'
+require 'dslimple/record'
+require 'dslimple/dsl'
+require 'dslimple/query'
+require 'dslimple/query_builder'
+require 'dslimple/exporter'
+require 'dslimple/applier'
+
+module Dslimple
+  ESCAPE_SINGLE_QUOTE_REGEXP = /[^\\]'/
+
+  def self.escape_single_quote(string)
+    string.gsub(ESCAPE_SINGLE_QUOTE_REGEXP) do |match|
+      match[0] + "\\'"
+    end
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: dslimple
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Sho Kusano
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  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: dnsimple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+description: DSLimple is a tool to manage DNSimple. It defines the state of DNSimple
+  using DSL, and updates DNSimple according to DSL.
+email:
+- sho-kusano@zeny.io
+executables:
+- dslimple
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dslimple.gemspec
+- exe/dslimple
+- lib/dslimple.rb
+- lib/dslimple/applier.rb
+- lib/dslimple/cli.rb
+- lib/dslimple/domain.rb
+- lib/dslimple/dsl.rb
+- lib/dslimple/dsl/domain.rb
+- lib/dslimple/dsl/error.rb
+- lib/dslimple/dsl/record.rb
+- lib/dslimple/exporter.rb
+- lib/dslimple/query.rb
+- lib/dslimple/query_builder.rb
+- lib/dslimple/record.rb
+- lib/dslimple/version.rb
+homepage: https://github.com/zeny-io/dslimple
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: DSLimple is a tool to manage DNSimple.
+test_files: []