dslimple 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dce8b719b5649f05c0aeb1797495cbba95c8498c
-  data.tar.gz: a3109feace113af1c23069889437e116d9684832
+SHA256:
+  metadata.gz: c0e4eb296b2f5d52fc5b6e2193573eb53c1799f34e9eb6829e9c0976b20a3384
+  data.tar.gz: ff7fbd6fd7854910d2c297a1358a1563dbcef9b43364fc7a3135f3feaad523d5
 SHA512:
-  metadata.gz: f2507e4cf8ddba6bc18f92e4e94e189952b7841a8fc3a6a466b38326b8f70f7f407ea0985c31b2459a0c43b32f9450150317ae4dc4ca4171af5d7384d840a133
-  data.tar.gz: 90a69e82def3664778c36c3617d7700ff8c5dbfd590a2d01d59addbede675bba08f3ced38638c69b6a132b1bb7c55f0344ca2391f6d5ee27c5d542c8a87a3dbd
+  metadata.gz: 22bcecdfd5cbc84328903cf2ab8fbac86c188da4977ace84cff5eafac18c76ab2213674c89d68911ceea169277c9fe280cff4ed0d1599b71104391a68360e576
+  data.tar.gz: 98035651710a0273eaebb74fdba659226ea94e225a59f11da494f2fc4e2c0646be78d975d37ddc274a703b9548e5a95f9408352114e8f90cf786f5425a44e89c

data/.gitignore

@@ -7,5 +7,6 @@
 /pkg/
 /spec/reports/
 /tmp/
-/Domainfile
-/domainfiles
+/Zonefile
+/zonefiles
+/.envrc

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/dslimple.gemspec

@@ -21,8 +21,9 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler', '~> 1.11'
   spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'rubocop'
 
-  spec.add_dependency 'dnsimple', '~> 3.0'
+  spec.add_dependency 'dnsimple', '~> 4.0'
   spec.add_dependency 'thor', '~> 0.19'
 end

data/lib/dslimple/applier.rb

@@ -1,5 +1,5 @@
 require 'dslimple'
-require 'pp'
+require 'dslimple/query_builder'
 
 class Dslimple::Applier
   OPERATION_COLORS = {
@@ -8,11 +8,10 @@ class Dslimple::Applier
     deletion: :red
   }.freeze
 
-  attr_reader :api_client, :account, :shell, :options
+  attr_reader :client, :shell, :options
 
-  def initialize(api_client, account, shell, options = {})
-    @api_client = api_client
-    @account = account
+  def initialize(client, shell, options = {})
+    @client = client
     @shell = shell
     @options = options
   end
@@ -22,10 +21,10 @@ class Dslimple::Applier
 
     dsl.execute
 
-    expected_domains = dsl.transform
-    expected_domains.select! { |domain| options[:only].include?(domain.name) } if options[:only].any?
+    expected_zones = dsl.transform
+    expected_zones.select! { |zone| options[:only].include?(zone.name) } unless options[:only].empty?
 
-    @buildler = Dslimple::QueryBuilder.new(fetch_domains, expected_domains)
+    @buildler = Dslimple::QueryBuilder.new(fetch_zones, expected_zones, options)
     @buildler.execute
     queries = @buildler.filtered_queries(options)
 
@@ -41,11 +40,10 @@ class Dslimple::Applier
     apply(queries)
   end
 
-  def fetch_domains
-    domains = api_client.domains.all_domains(account.id).data.map { |domain| Dslimple::Domain.new(domain.name, api_client, account, id: domain.id) }
-    domains.each(&:fetch_records!)
-    domains.select! { |domain| options[:only].include?(domain.name) } if options[:only].any?
-    domains
+  def fetch_zones
+    zones = client.all_zones(with_records: true)
+    zones.select! { |zone| options[:only].include?(zone.name) } if options[:only].any?
+    zones
   end
 
   def show_plan(queries)
@@ -59,7 +57,7 @@ class Dslimple::Applier
     shell.say('Apply', :bold)
     queries.each do |query|
       show_query(query)
-      query.execute(api_client, account)
+      query.execute(client, client.account_id)
     end
   end
 

data/lib/dslimple/cli.rb

@@ -2,30 +2,32 @@ require 'thor'
 require 'dnsimple'
 require 'json'
 require 'dslimple'
+require 'dslimple/dsl'
+require 'dslimple/client'
 
 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 :access_token, type: :string, aliases: %w(-a), desc: 'Your API token'
   class_option :sandbox, type: :boolean, default: ENV['DSLIMPLE_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 :file, type: :string, default: 'Zonefile', aliases: %w(-f), desc: 'Export zonefile path(- is stdout)'
+  method_option :dir, type: :string, default: './zonefiles', 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'
+  method_option :ignore, type: :array, default: ['system', 'child'], desc: 'Ignore record types'
   def export
-    exporter = Dslimple::Exporter.new(api_client, account, options)
+    require 'dslimple/exporter'
+    fd = options[:file] == '-' ? STDOUT : File.open(options[:file].to_s, 'w')
+
+    exporter = Dslimple::Exporter.new(client, fd, options)
 
     exporter.execute
+
+    fd.close
   rescue => e
     rescue_from(e)
   end
@@ -33,13 +35,15 @@ class Dslimple::CLI < Thor
   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 :ignore, type: :array, default: ['system', 'child'], desc: 'Ignore record types'
+  method_option :file, type: :string, default: 'Zonefile', aliases: %w(-f), desc: 'Source Zonefile path'
+  method_option :addition, type: :boolean, default: true, desc: 'Allow add records'
+  method_option :modification, type: :boolean, default: true, desc: 'Allow modify records'
+  method_option :deletion, type: :boolean, default: true, desc: 'Allow delete 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, account, self, options)
+    require 'dslimple/applier'
+    applier = Dslimple::Applier.new(client, self, options)
 
     applier.execute
   rescue => e
@@ -50,17 +54,10 @@ class Dslimple::CLI < Thor
 
   private
 
-  def account
-    @account ||= api_client.identity.whoami.data[:account]
-  end
-
-  def api_client
-    @api_client ||= Dnsimple::Client.new(
-      username: options[:email] || ENV['DSLIMPLE_EMAIL'],
+  def client
+    @aclient ||= Dslimple::Client.new(
       access_token: options[:api_token] || ENV['DSLIMPLE_API_TOKEN'] || ENV['DSLIMPLE_ACCESS_TOKEN'],
-      domain_api_token: options[:domain_token] || ENV['DSLIMPLE_DOMAIN_TOKEN'],
-      base_url: options[:sandbox] ? SANDBOX_API_ENDPOINT : nil,
-      user_agent: USER_AGENT
+      sandbox: options[:sandbox]
     )
   end
 

data/lib/dslimple/client.rb

@@ -0,0 +1,67 @@
+require 'dnsimple'
+require 'dslimple/zone'
+require 'dslimple/record'
+
+class Dslimple::Client < Dnsimple::Client
+  SANDBOX_URL = 'https://api.sandbox.dnsimple.com'
+  USER_AGENT = "dslimple v#{Dslimple::VERSION}"
+
+  def initialize(sandbox: false, **options)
+    options[:base_url] = SANDBOX_URL if sandbox
+    options[:user_agent] = USER_AGENT
+
+    options[:access_token] ||= ENV['DNSIMPLE_ACCESS_TOKEN']
+
+    super(options)
+  end
+
+  def account_id
+    return @account_id if instance_variable_defined?(:@account_id)
+
+    whoami = identity.whoami.data
+    @account_id = whoami.user&.id
+    @account_id = whoami.account.id if whoami.account
+
+    @account_id
+  end
+
+  def all_zones(with_records: false)
+    response = zones.list_zones(account_id)
+
+    zones = []
+    while response
+      zones = zones + response.data.map do |domain|
+        zone = Dslimple::Zone.new(domain.name)
+        zone.records = all_records(zone) if with_records
+        zone
+      end
+
+      response = if response.page < response.total_pages
+                   zones.list_zones(account_id, domain, page: response.page + 1)
+                 else
+                   nil
+                 end
+    end
+    zones
+  end
+
+  def all_records(zone)
+    response = zones.list_records(account_id, zone.name)
+
+    records = []
+    while response
+      records = records + response.data.map do |record|
+        record = Dslimple::Record.new(record)
+        record.zone = zone.name
+        record
+      end
+
+      response = if response.page < response.total_pages
+                   zones.list_records(account_id, domain, page: response.page + 1)
+                 else
+                   nil
+                 end
+    end
+    records
+  end
+end

data/lib/dslimple/dsl/record.rb

@@ -1,25 +1,39 @@
 require 'dslimple/dsl'
 
 class Dslimple::DSL::Record
-  attr_reader :name, :content, :options
+  ATTRIBUTES = %i[zone name type content ttl priority regions]
+  attr_accessor *ATTRIBUTES
 
-  def initialize(name, options = {}, &block)
-    @name = name
-    @options = options
+  def initialize(options = {}, &block)
+    options.each_pair do |key, val|
+      break unless respond_to?("#{key}=")
+
+      send("#{key}=", val)
+    end
 
     returned_content = instance_eval(&block)
     @content ||= returned_content
   end
 
-  def priority(n)
-    @options[:priority] = n.to_s.to_i
+  def [](key)
+    respond_to?(key) ? send(key) : nil
+  end
+
+  ATTRIBUTES.each do |attr|
+    define_method(attr) do |v = nil|
+      v ? instance_variable_set("@#{attr}", v) : instance_variable_get("@#{attr}")
+    end
+
+    define_method("#{attr}=") do |v|
+      instance_variable_set("@#{attr}", v)
+    end
   end
 
-  def ttl(n)
-    @options[:ttl] = n.to_s.to_i
+  def region(v = nil)
+    self.regions = [v].flatten
   end
 
-  def content(c = nil)
-    c ? @content = c : @content
+  def region=(v)
+    self.regions = [v].flatten
   end
 end

data/lib/dslimple/dsl/{domain.rb → zone.rb}

@@ -1,6 +1,7 @@
-require 'dslimple/dsl'
+require 'dslimple/dsl/record'
+require 'dslimple/record'
 
-class Dslimple::DSL::Domain
+class Dslimple::DSL::Zone
   attr_reader :name, :records
 
   def initialize(name, &block)
@@ -15,11 +16,12 @@ class Dslimple::DSL::Domain
       options = options.merge(name)
       name = ''
     end
+    options = options.merge(zone: @name, name: name)
 
-    @records << Dslimple::DSL::Record.new(name, options, &block)
+    @records << Dslimple::DSL::Record.new(options, &block)
   end
 
-  Dslimple::Record::RECORD_TYPES.each do |type|
+  Dslimple::Record::RECORD_TYPES.map(&:downcase).each do |type|
     class_eval(<<-EOC)
       def #{type}_record(name = {}, options = {}, &block)
         record(name, options.merge(type: :#{type}), &block)

data/lib/dslimple/dsl.rb

@@ -5,7 +5,7 @@ class Dslimple::DSL
   def initialize(file, context = {})
     @file = Pathname.new(file)
     @dir = @file.dirname
-    @domains = []
+    @zones = []
     @files = []
 
     @context = context
@@ -20,6 +20,8 @@ class Dslimple::DSL
       evaluate(@dir.join(path))
     elsif @dir.join("#{path}.rb").exist?
       evaluate(@dir.join("#{path}.rb"))
+    elsif @dir.join("#{path}.zone").exist?
+      evaluate(@dir.join("#{path}.zone"))
     else
       Kernel.require(path)
     end
@@ -34,15 +36,15 @@ class Dslimple::DSL
     raise Dslimple::DSL::Error, "#{e.class}: #{e.message}", cleanup_backtrace(e.backtrace)
   end
 
-  def domain(name, &block)
-    @domains << Dslimple::DSL::Domain.new(name, &block)
+  def zone(name, &block)
+    @zones << Dslimple::DSL::Zone.new(name, &block)
   end
 
   def transform
-    @domains.map do |domain|
-      Dslimple::Domain.new(domain.name, nil, nil).tap do |model|
-        model.records = domain.records.map do |record|
-          Dslimple::Record.new(model, record.options[:type], record.name, record.content, record.options)
+    @zones.map do |zone|
+      Dslimple::Zone.new(zone.name).tap do |model|
+        model.records = zone.records.map do |record|
+          Dslimple::Record.new(record)
         end
       end
     end
@@ -60,6 +62,6 @@ class Dslimple::DSL
   end
 end
 
-require 'dslimple/dsl/domain'
+require 'dslimple/dsl/zone'
 require 'dslimple/dsl/record'
 require 'dslimple/dsl/error'

data/lib/dslimple/exporter.rb

@@ -2,55 +2,55 @@ require 'pathname'
 require 'dslimple'
 
 class Dslimple::Exporter
-  attr_reader :api_client, :account, :options, :domains
+  attr_reader :client, :file, :options, :zones, :onlies
 
-  def initialize(api_client, account, options)
-    @api_client = api_client
-    @account = account
+  def initialize(client, file, options)
+    @client = client
+    @file = file
     @options = options
-    @domains = []
+    @onlies = [options[:only]].flatten.map(&:to_s).reject(&:empty?)
   end
 
   def execute
-    @domains = fetch_domains
+    @zones = client.all_zones(with_records: true)
 
     if options[:split] && options[:dir]
-      split_export(options[:dir], options[:file])
+      split_export(file, options[:dir])
     else
-      export(options[:file], domains)
+      export(file, clean_zones(zones))
     end
   end
 
-  def fetch_domains
-    domains = api_client.domains.all_domains(account.id).data.map { |domain| Dslimple::Domain.new(domain.name, api_client, account) }
-    domains.each(&:fetch_records!)
-    domains.select! { |domain| options[:only].include?(domain.name) } unless options[:only].empty?
-    domains
+  def export(fd, export_zones)
+    write_modeline(fd)
+    fd.puts export_zones.map { |zone| zone.to_dsl(options) }.join("\n")
   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)
+  def split_export(fd, dir)
     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)}'"
+    write_modeline(file)
+    clean_zones(zones).each do |zone|
+      zonefile = dir.join("#{zone.name}.zone")
+      File.open(zonefile, 'w') do |fd|
+        export(fd, [zone])
       end
+      fd.puts "require '#{zonefile.relative_path_from(file.dirname)}'"
     end
   end
 
   def write_modeline(fd)
     fd << "# -*- mode: ruby -*-\n# vi: set ft=ruby :\n\n" if options[:modeline]
   end
+
+  protected
+
+  def clean_zones(zones)
+    return zones if onlies.empty?
+
+    zones.select do |zone|
+      onlies.include?(zone.name)
+    end
+  end
 end

data/lib/dslimple/query.rb

@@ -1,12 +1,12 @@
 require 'dslimple'
 
 class Dslimple::Query
-  attr_reader :operation, :target, :domain, :params
+  attr_reader :operation, :target, :zone, :params
 
-  def initialize(operation, target, domain, params = {})
+  def initialize(operation, target, zone, params = {})
     @operation = operation
     @target = target
-    @domain = domain
+    @zone = zone
     @params = params
   end
 
@@ -19,17 +19,17 @@ class Dslimple::Query
   end
 
   def to_s
-    if target == :domain
-      domain.name.to_s
+    if target == :zone
+      zone.to_s
     else
-      %(#{params[:record_type].to_s.rjust(5)} #{params[:name].to_s.rjust(10)}.#{domain.name} (#{record_options.join(', ')}) "#{params[:content]}")
+      %(#{params[:type].to_s.rjust(5)} #{params[:name].to_s.rjust(10)}.#{zone.to_s} (#{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
+      options << "#{k}: #{v}" if %i(ttl priority regions).include?(k) && v
     end
     options
   end
@@ -38,23 +38,25 @@ class Dslimple::Query
     __send__("execute_#{target}", api_client, account)
   end
 
-  def execute_domain(api_client, account)
+  def execute_zone(api_client, account_id)
     case operation
     when :addition
-      api_client.registrar.register_domain(account.id, domain.name, registrant_id: account.id, auto_renew: true)
+      # TODO: Support registration
+      # api_client.registrar.register_zone(account_id, zone, registrant_id: account.id, auto_renew: true)
     when :deletion
-      api_client.domains.delete_domain(account.id, domain.name)
+      # TODO: Support deletion
+      # api_client.zones.delete_zone(account_id, zone)
     end
   end
 
-  def execute_record(api_client, account)
+  def execute_record(api_client, account_id)
     case operation
     when :addition
-      api_client.zones.create_record(account.id, domain.name, params)
+      api_client.zones.create_record(account_id, zone, params)
     when :modification
-      api_client.zones.update_record(account.id, domain.name, params[:id], params)
+      api_client.zones.update_record(account_id, zone, params[:id], params)
     when :deletion
-      api_client.zones.delete_record(account.id, domain.name, params[:id])
+      api_client.zones.delete_record(account_id, zone, params[:id])
     end
   end
 end

data/lib/dslimple/query_builder.rb

@@ -1,41 +1,43 @@
 require 'dslimple'
+require 'dslimple/query'
 
 class Dslimple::QueryBuilder
-  attr_reader :queries
-  attr_reader :expected_domains, :current_domains
+  attr_reader :queries, :options
+  attr_reader :expected_zones, :current_zones
   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]
+  def initialize(current_zones, expected_zones, options = {})
+    @current_zones = Hash[*current_zones.map { |zone| [zone.name, zone] }.flatten]
+    @expected_zones = Hash[*expected_zones.map { |zone| [zone.name, zone] }.flatten]
+    @options = options
   end
 
-  def append_domains
-    @append_domains ||= expected_domains.values.reject { |domain| current_domains.key?(domain.name) }
+  def append_zones
+    @append_zones ||= expected_zones.values.reject { |zone| current_zones.key?(zone.name) }
   end
 
-  def delete_domains
-    @delete_domains ||= current_domains.values.reject { |domain| expected_domains.key?(domain.name) }
+  def delete_zones
+    @delete_zones ||= current_zones.values.reject { |zone| expected_zones.key?(zone.name) }
   end
 
   def execute
-    @append_records = append_domains.map(&:records_without_soa_ns).flatten
+    @append_records = append_zones.map { |z| z.clean_records(options[:ignore]) }.flatten
     @change_records = []
-    @delete_records = delete_domains.map(&:records_without_soa_ns).flatten
+    @delete_records = delete_zones.map { |z| z.clean_records(options[:ignore]) }.flatten
 
-    expected_domains.each_pair do |name, domain|
-      execute_records(name, domain)
+    expected_zones.each_pair do |name, zone|
+      execute_records(name, zone)
     end
 
     build_queries
   end
 
-  def execute_records(domain_name, domain)
-    current_domain = current_domains[domain_name]
-    return unless current_domain
+  def execute_records(zone_name, zone)
+    current_zone = current_zones[zone_name]
+    return unless current_zone
 
-    current_records = current_domain.records_without_soa_ns.dup
-    domain.records_without_soa_ns.each do |record|
+    current_records = current_zone.clean_records(options[:ignore]).dup
+    zone.clean_records(options[:ignore]).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 }
@@ -53,24 +55,24 @@ class Dslimple::QueryBuilder
   def build_queries
     @queries = []
 
-    append_domains.each do |domain|
-      @queries << Dslimple::Query.new(:addition, :domain, domain)
+    append_zones.each do |zone|
+      @queries << Dslimple::Query.new(:addition, :zone, zone)
     end
 
     append_records.each do |record|
-      @queries << Dslimple::Query.new(:addition, :record, record.domain, record.to_params)
+      @queries << Dslimple::Query.new(:addition, :record, record.zone, 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))
+      @queries << Dslimple::Query.new(:modification, :record, new.zone, new.to_params.merge(id: old.id))
     end
 
     delete_records.each do |record|
-      @queries << Dslimple::Query.new(:deletion, :record, record.domain, record.to_params)
+      @queries << Dslimple::Query.new(:deletion, :record, record.zone, record.to_params)
     end
 
-    delete_domains.each do |domain|
-      @queries << Dslimple::Query.new(:deletion, :domain, domain)
+    delete_zones.each do |zone|
+      @queries << Dslimple::Query.new(:deletion, :zone, zone)
     end
 
     @queries

data/lib/dslimple/record.rb

@@ -1,114 +1,82 @@
 require 'dslimple'
+require 'dnsimple'
+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
+  RECORD_TYPES = %w[A ALIAS CNAME MX SPF URL TXT NS SRV NAPTR PTR AAAA SSHFP HINFO POOL CAA]
+  DEFAULT_REGIONS = ['global']
 
-    records
-  end
-
-  RECORD_TYPES.each do |type|
-    class_eval(<<-EOC)
-      def #{type}?
-        type == :#{type}
-      end
-    EOC
-  end
+  attr_accessor :id, :zone, :name, :type, :ttl, :priority, :content, :regions, :system_record
 
-  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 initialize(attrs = {})
+    attrs = normalize_attrs(attrs) if attrs.is_a?(Dnsimple::Struct::ZoneRecord)
 
-  def escaped_content
-    Dslimple.escape_single_quote(content)
+    @id = attrs[:id]
+    @zone = attrs[:zone_id] || attrs[:zone]
+    @name = attrs[:name]
+    @type = attrs[:type].to_s.downcase.to_sym
+    @ttl = attrs[:ttl]
+    @parent_id = attrs[:parent_id]
+    @priority = attrs[:priority]
+    @content = attrs[:content]
+    @regions = attrs[:regions] || DEFAULT_REGIONS
+    @system_record = attrs[:system_record]
   end
 
-  def like_spf?
-    txt? && content.match(SPF_PREFIX)
+  def [](key)
+    send(key)
   end
 
-  def like_alias?
-    txt? && content.match(ALIAS_PREFIX)
+  def system_record?
+    @system_record == true
   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}"
+  def child_record?
+    !@parent_id.nil?
   end
 
   def ==(other)
-    other.is_a?(Dslimple::Record) && other.domain == domain && other.hash == hash
+    other.is_a?(self.class) && hash == other.hash
   end
-  alias_method :eql, :==
 
   def ===(other)
-    other.is_a?(Dslimple::Record) && other.domain == domain && other.rough_hash == rough_hash
+    other.is_a?(self.class) && %i[zone name type].all? { |attr| send(attr).to_s == other.send(attr).to_s }
   end
 
   def hash
-    "#{type}:#{name}:#{content}:#{ttl}:#{priority}"
-  end
-
-  def rough_hash
-    "#{type}:#{name}:#{content}"
+    [zone.to_s, name, type, ttl, priority, content, regions.join('|'), !!system_record].hash
   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
+  def to_dsl(options = {})
+  [
+    "  #{type.to_s.downcase}_record(#{name.inspect}) do",
+    priority ? "    priority #{priority.inspect}" : "",
+    ttl ? "    ttl #{ttl}" : "",
+    regions != DEFAULT_REGIONS ? "    regions #{regions.inspect}" : "",
+    "    content #{content.inspect}",
+    "  end",
+  ].reject(&:empty?).join("\n")
   end
 
   def to_params
     {
-      id: id,
-      type: type.to_s.upcase,
+      id: @id,
       name: name,
+      type: type.to_s.upcase,
       content: content,
       ttl: ttl,
-      priority: priority
+      priority: priority,
+      regions: regions,
     }
   end
 
-  def inspect
-    "<Dslimple::Record #{type.to_s.upcase} #{name}: #{content}>"
+  private
+
+  def normalize_attrs(record)
+    attrs = {}
+    record.instance_variables.each do |var|
+      attrs[:"#{var.to_s.sub(/^@/, '')}"] = record.instance_variable_get(var)
+    end
+    attrs
   end
 end

data/lib/dslimple/version.rb

@@ -1,3 +1,3 @@
 module Dslimple
-  VERSION = '1.1.0'.freeze
+  VERSION = '2.0.0'.freeze
 end

data/lib/dslimple/zone.rb

@@ -0,0 +1,46 @@
+require 'dslimple'
+require 'dslimple/record'
+
+class Dslimple::Zone
+  attr_reader :name
+  attr_accessor :records
+
+  def initialize(name)
+    @name = name
+    @records = []
+  end
+
+  def ==(other)
+    other.is_a?(self.class) && hash == other.hash && records.hash == other.records.hash
+  end
+
+  def ===(other)
+    other.is_a?(self.class) && hash == other.hash
+  end
+
+  def hash
+    [name, records.map(&:hash)].hash
+  end
+
+  def to_s
+    name
+  end
+
+  def to_dsl(options = {})
+<<DSL
+zone #{name.inspect} do
+#{clean_records(options[:ignore]).map { |record| record.to_dsl(options) }.join("\n\n")}
+end
+DSL
+  end
+
+  def clean_records(ignores)
+    ignores = [ignores].flatten.map(&:to_s)
+
+    records.select do |record|
+      next false if ignores.include?('system') && record.system_record?
+      next false if ignores.include?('child') && record.child_record?
+      true
+    end
+  end
+end

data/lib/dslimple.rb

@@ -1,18 +1 @@
 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

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dslimple
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Sho Kusano
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-02 00:00:00.000000000 Z
+date: 2018-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -90,6 +104,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - ".rubocop.yml"
 - Gemfile
 - LICENSE.txt
@@ -102,16 +117,17 @@ files:
 - lib/dslimple.rb
 - lib/dslimple/applier.rb
 - lib/dslimple/cli.rb
-- lib/dslimple/domain.rb
+- lib/dslimple/client.rb
 - lib/dslimple/dsl.rb
-- lib/dslimple/dsl/domain.rb
 - lib/dslimple/dsl/error.rb
 - lib/dslimple/dsl/record.rb
+- lib/dslimple/dsl/zone.rb
 - lib/dslimple/exporter.rb
 - lib/dslimple/query.rb
 - lib/dslimple/query_builder.rb
 - lib/dslimple/record.rb
 - lib/dslimple/version.rb
+- lib/dslimple/zone.rb
 homepage: https://github.com/zeny-io/dslimple
 licenses:
 - MIT
@@ -132,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: DSLimple is a tool to manage DNSimple.

data/lib/dslimple/domain.rb

@@ -1,49 +0,0 @@
-require 'dslimple'
-
-class Dslimple::Domain
-  attr_reader :name, :id
-  attr_accessor :api_client, :account, :records
-
-  def initialize(name, api_client, account, options = {})
-    @name = name
-    @id = options[:id]
-    @api_client = api_client
-    @account = account
-    @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.zones.all_records(account.id, name).data.map do |record|
-      Dslimple::Record.new(self, 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