str_dn_2030 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fd3349718acb66b742700b924e4254fea002a00d
+  data.tar.gz: 74c3b4739709f818f31b37fd4a365a443d88fe5c
+SHA512:
+  metadata.gz: ecf0ed5e95d92abe4ec9531506f545626dd291d835bbbeb515505d60f8cd0acb3cd85a4a90044a25ba80a3693ec5c3d402502484219b540eb530d1ec0be8a2bb
+  data.tar.gz: e9afbea4adfe919f75f2af5ecf288522799b336b6f131546c529a7386977feccac1cd3e0fa12ba8e6f939084cf4cdf804635fda775a7a20348f65d311e60adfb

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'sinatra'
+gem 'puma'
+
+# Specify your gem's dependencies in str_dn_2030.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Shota Fukumori (sora_h)
+
+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,114 @@
+# StrDn2030
+
+TODO: Write a gem description
+
+## Installation
+
+``` ruby
+gem 'str_dn_2030'
+gem 'sinatra' # if you want to use str_dn_2030/web
+```
+
+Or install it yourself as:
+
+    $ gem install str_dn_2030
+
+## Usage
+
+### as a Ruby library
+
+#### Connect
+
+``` ruby
+require 'str_dn_2030'
+
+remote = StrDn2030.new('x.x.x.x') # pass your amp's IP address
+remote.connect
+
+zone = remote.zones(0) # main zone
+```
+
+#### See status
+
+``` ruby
+p zone.volume
+p zone.powered_on?
+p zone.muted?
+p zone.headphone?
+```
+
+#### Control input
+
+``` ruby
+input = zone.active_input
+p input.name
+p input.preset_name
+
+p zone.inputs #=> Hash
+
+zone.inputs['Chrome'].activate!
+zone.active_input = zone.inputs['Apple TV']
+```
+
+#### Control volume
+
+``` ruby
+zone.volume = 30
+zone.mute = true
+zone.mute = false
+```
+
+### HTTP interface
+
+``` ruby
+# config.ru
+require 'str_dn_2030'
+require 'str_dn_2030/web'
+
+remote = StrDn2030::Remote.new('x.x.x.x')
+remote.connect
+StrDn2030::Web.set :remote, remote
+
+run StrDn2030::Web
+```
+
+```
+curl http://localhost:9292/zones/0
+```
+
+```
+curl http://localhost:9292/zones/0/inputs
+```
+
+```
+curl http://localhost:9292/zones/0/volume
+curl -X PUT \
+     -H 'Content-Type: application/json' \
+     -d '{"volume": 25}' \
+     http://localhost:9292/zones/0/volume
+curl -X PUT \
+     -H 'Content-Type: application/json' \
+     -d '{"mute": true}' \
+     http://localhost:9292/zones/0/volume
+```
+
+```
+curl 'http://localhost:9292/zones/0/inputs/Apple+TV'
+curl -X POST 'http://localhost:9292/zones/0/inputs/Apple+TV/activate'
+```
+
+```
+curl http://localhost:9292/zones/0/active
+curl -X PUT \
+     -H 'Content-Type: application/json' \
+     -d '{"input": "Apple TV"}' \
+     http://localhost:9292/zones/0/active
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/sorah/str_dn_2030/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/config.ru

@@ -0,0 +1,12 @@
+require 'str_dn_2030'
+require 'str_dn_2030/web'
+
+remote = StrDn2030::Remote.new(
+  ENV['STRDN2030_HOST'],
+  ENV['STRDN2030_PORT'] ? ENV['STRDN2030_PORT'].to_i : 33335
+)
+remote.connect
+
+StrDn2030::Web.set :remote, remote
+StrDn2030::Web.set :max_volume, ENV['STRDN2030_MAX_VOLUME'] ? ENV['STRDN2030_MAX_VOLUME'].to_i : 33
+run StrDn2030::Web

data/lib/str_dn_2030.rb

@@ -0,0 +1,292 @@
+require 'str_dn_2030/version'
+require 'str_dn_2030/input'
+require 'str_dn_2030/zone'
+require 'socket'
+require 'thread'
+
+module StrDn2030
+  class Remote
+    VOLUME_STATUS_REGEXP = /\x02\x06\xA8\x92(?<zone>.)(?<type>.)(?<volume>..)./nm
+    STATUS_REGEXP = /\x02\x07\xA8\x82(?<zone>.)(?<ch>.)(?<ch2>.)(?<flag1>.)(?<unused>.)./nm
+
+    INPUT_REGEXP = /(?<index>.)(?<audio>.)(?<video>.)(?<icon>.)(?<preset_name>.{8})(?<name>.{8})(?<skip>.)/mn
+    INPUTLIST_REGEXP = Regexp.new(
+      '\x02\xD7\xA8\x8B(?<zone>.)' \
+      "(?<inputs>(?:#{INPUT_REGEXP}){10})" \
+      '\x00\x00.',
+      Regexp::MULTILINE,
+      'n'
+    )
+    def initialize(host, port = 33335)
+      @host, @port = host, port
+
+      @socket = nil
+      @receiver_thread = nil
+
+      @lock = Mutex.new
+      @receiver_lock = Mutex.new
+      @hook = nil
+
+      @listeners = {}
+      @listeners_lock = Mutex.new
+
+      @inputs = {}
+      @statuses = {}
+    end
+
+    attr_reader :inputs, :host, :port
+
+    def inspect
+      "#<#{self.class.name}: #{@host}:#{@port}>"
+    end
+
+    def hook(&block)
+      if block_given?
+        @hook = block
+      else
+        @hook
+      end
+    end
+
+    def listen(type, filter = nil)
+      Thread.current[:strdn2030_filter] = filter
+      @listeners_lock.synchronize {
+        @listeners[type] ||= []
+        @listeners[type] << Thread.current
+      }
+
+      sleep
+
+      data = Thread.current[:strdn2030_data]
+      Thread.current[:strdn2030_data] = nil
+      data
+    end
+
+
+    def connected?
+      !!@socket
+    end
+
+    def connect
+      disconnect if connected?
+
+      @lock.synchronize do
+        @socket = TCPSocket.open(@host, @port)
+        start_receiver
+        reload_input
+        self
+      end
+    end
+
+    def disconnect
+      @lock.synchronize do
+        return unless @socket
+        @socket.close unless @socket.closed?
+        @socket = nil
+        stop_receiver
+      end
+    end
+
+    def reload
+      reload_input
+      @statuses = {}
+      self
+    end
+
+    def zone(zone_id)
+      Zone.new(self, zone_id.is_a?(String) ? zone_id.ord : zone_id.to_i)
+    end
+
+    #### These are private api
+
+    def status_get(zone_id = 0)
+      @statuses[zone_id] || begin
+        zone = zone_id.chr('ASCII-8BIT')
+        send "\x02\x03\xA0\x82".b + zone + "\x00".b
+        listen(:status, zone_id)
+      end
+    end
+
+    def volume_get(zone_id, type = "\x03".b)
+      zone = zone_id.chr('ASCII-8BIT')
+      send "\x02\x04\xa0\x92".b + zone + type + "\x00".b
+      listen(:volume, zone_id)
+    end
+
+    def volume_set(zone_id, other, type = "\x03".b)
+      zone = zone_id.chr('ASCII-8BIT')
+      send "\x02\x06\xa0\x52".b + zone + type + [other.to_i].pack('s>') + "\x00".b
+      listen(:success)
+      other
+    end
+
+    def active_input_get(zone_id)
+      current = status_get(zone_id)[:ch][:video]
+      inputs[zone_id][current] || self.reload_input.inputs[zone_id][current]
+    end
+
+    def active_input_set(zone_id, other)
+      new_input = if other.is_a?(Input)
+        raise ArgumentError, "#{other.inspect} is not in zone #{zone_id}" unless other.zone == zone_id
+        other
+      else
+        inputs[zone_id][other] || self.reload_input.inputs[zone_id][other]
+      end
+
+      raise ArgumentError, "#{other.inspect} not exists" unless new_input
+      
+      zone = zone_id.chr('ASCII-8BIT')
+      send "\x02\x04\xa0\x42".b + zone + new_input.video + "\x00".b
+      listen(:success)
+      other
+    end
+
+    def mute_set(zone_id, new_mute)
+      zone = zone_id.chr('ASCII-8BIT')
+      send "\x02\x04\xa0\x53".b + zone + (new_mute ? "\x01".b : "\x00".b) + "\x00".b
+      listen(:success)
+      new_mute
+    end
+
+    def reload_input
+      @inputs = {}
+      get_input_list(0, 0)
+      listen(:input_list, 0)
+      get_input_list(0, 1)
+      listen(:input_list, 0)
+      get_input_list(1, 0)
+      listen(:input_list, 1)
+      get_input_list(1, 1)
+      listen(:input_list, 1)
+      self
+    end
+
+    private
+
+    def receiver_alive?
+      @receiver_thread && @receiver_thread.alive?
+    end
+
+    def start_receiver(if_dead=false)
+      return if if_dead && receiver_alive?
+      stop_receiver
+      @receiver_lock.synchronize do
+        debug [:start_receiver]
+        @receiver_thread = Thread.new(@socket, &method(:receiver))
+        @receiver_thread.abort_on_exception = true
+      end
+    end
+
+    def stop_receiver
+      @receiver_lock.synchronize do
+        debug [:stop_receiver]
+        @receiver_thread.kill if receiver_alive?
+        @receiver_thread = nil
+      end
+    end
+
+    def get_input_list(zone_id, page = 0)
+      send("\x02\x04\xa0\x8b".b + zone_id.chr('ASCII-8BIT') + page.chr('ASCII-8BIT') + "\x00".b)
+    end
+
+    def send(str)
+      start_receiver(true)
+      debug [:send, str]
+      @socket.write str
+    end
+
+    def receiver(socket)
+      buffer = "".b
+
+      hit = false
+      handle = lambda do |pattern, &handler|
+        if m = buffer.match(pattern)
+          hit = true
+          buffer.replace(m.pre_match + m.post_match)
+          handler[m]
+        end
+      end
+
+      while chunk = socket.read(1)
+        hit = false
+        buffer << chunk.b
+
+        handle.(STATUS_REGEXP, &method(:handle_status))
+        handle.(VOLUME_STATUS_REGEXP, &method(:handle_volume_status))
+        handle.(INPUTLIST_REGEXP, &method(:handle_input_list))
+
+        handle.(/\A\xFD/n) { delegate(:success) }
+        handle.(/\A\xFE/n) { delegate(:error) }
+
+        debug([:buffer_remain, buffer]) if hit && !buffer.empty?
+      end
+    end
+
+    def delegate(name, subtype = nil, *args)
+      wake_listener name, subtype, *args
+      @hook.call(name, *args) if @hook
+    end
+
+    def wake_listener(type, subtype, data = nil)
+      @listeners_lock.synchronize do
+        @listeners[type] ||= []
+        @listeners[type].each do |th|
+          next if th[:strdn2030_filter] && !(th[:strdn2030_filter] === subtype)
+          th[:strdn2030_data] = data
+          th.wakeup
+        end
+        @listeners[type].clear
+      end
+    end
+
+    def handle_status(m)
+      flag1 = m['flag1'].ord
+      flags = {
+        raw: [m['flag1']].map{ |_| _.ord.to_s(2).rjust(8,' ') },
+        power: flag1[0] == 1,
+        mute: flag1[1] == 1,
+        headphone: flag1[2] == 1,
+        unknown_6: flag1[5],
+      }
+      data = @statuses[m['zone'].ord] = {
+        zone: m['zone'], ch: {audio: m['ch'], video: m['ch2']}, flags: flags
+      }
+
+      delegate(:status, m['zone'].ord, data)
+    end
+
+    def handle_volume_status(m)
+      data = {zone: m['zone'], type: m['type'], volume: m['volume'].unpack('s>').first}
+      delegate(:volume, m['zone'].ord, data)
+    end
+
+    def handle_input_list(m)
+      #p m
+      inputs = {}
+      zone = m['zone'].ord
+      m['inputs'].scan(INPUT_REGEXP).each do |input_line|
+        idx, audio, video, icon, preset_name, name, skip_flags = input_line
+
+        input = inputs[audio] = inputs[video] = Input.new(
+          self,
+          zone,
+          idx,
+          audio,
+          video,
+          icon,
+          preset_name,
+          name,
+          skip_flags,
+        )
+        inputs[input.name] = input
+      end
+      (@inputs[zone] ||= {}).merge! inputs
+      delegate :input_list, zone, inputs
+    end
+
+    def debug(*args)
+      p(*args) if ENV["STR_DN_2030_DEBUG"]
+    end
+  end
+end
+

data/lib/str_dn_2030/input.rb

@@ -0,0 +1,83 @@
+module StrDn2030
+  class Input
+    def initialize(parent, zone, index, audio, video, icon, preset_name, name, skip)
+      @parent = parent
+      @zone = zone
+      @index = index.dup.b.freeze
+      @audio = audio.dup.b.freeze
+      @video = video.dup.b.freeze
+      @icon = icon.dup.b.freeze
+      @preset_name = preset_name.strip.freeze
+      @name = name.strip.freeze
+      @skip_flags = skip.dup.b.freeze
+    end
+
+    attr_reader :parent,
+      :zone, :index,
+      :audio, :video,
+      :icon,
+      :preset_name, :name,
+      :skip_flags
+
+    def inspect
+      "#<#{self.class.name}: #{name} @ #{parent.host}:#{parent.port}/#{zone}>"
+    end
+
+    def activate!
+      parent.zone(self.zone).active_input = self
+      nil
+    end
+
+    def active?
+      parent.zone(self.zone).active_input == self
+    end
+
+    def skipped?
+      skip[:watch] && skip[:listen]
+    end
+
+    def watch_skipped?
+      skip[:watch]
+    end
+
+    def listen_skipped?
+      skip[:listen]
+    end
+
+    def skipped_any?
+      skip[:watch] || skip[:listen]
+    end
+
+    def skip
+      @skip ||= begin
+        {raw: skip_flags}.tap do |_|
+          _.merge!({
+            "\x11".b => {watch: true,  listen: true},
+            "\x21".b => {watch: true,  listen: true},
+            "\x30".b => {watch: false, listen: false},
+            "\x10".b => {watch: false, listen: true},
+            "\x20".b => {watch: true,  listen: false},
+          }[skip_flags.b] || {})
+        end
+      end
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && self.video == other.video && self.audio == other.audio
+    end
+
+    def as_json
+      {
+        zone: zone,
+        index: index,
+        audio: audio,
+        video: video,
+        icon: icon,
+        preset_name: preset_name,
+        name: name,
+        skip: skip,
+        active: active?,
+      }
+    end
+  end
+end

data/lib/str_dn_2030/version.rb

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

data/lib/str_dn_2030/web.rb

@@ -0,0 +1,154 @@
+require 'str_dn_2030'
+require 'sinatra/base'
+require 'json'
+
+module StrDn2030
+  class Web < Sinatra::Base
+    set :max_volume, nil
+
+    helpers do
+      def remote
+        self.class.remote
+      end
+
+      def max_volume
+        self.class.max_volume
+      end
+    end
+
+    get '/' do
+      'strdn2030'
+    end
+
+    post '/reload' do
+      remote.reload
+      status 204
+    end
+
+    get '/zones/:zone' do
+      content_type :json
+      zone = remote.zone(params[:zone].to_i)
+      {
+        zone: params[:zone],
+        volume: zone.volume,
+        active_input: zone.active_input.as_json,
+        mute: zone.muted?,
+        power: zone.powered_on?,
+        headphone: zone.headphone?,
+      }.to_json
+    end
+
+    get '/zones/:zone/inputs' do
+      content_type :json
+      zone = remote.zone(params[:zone].to_i)
+      inputs = Hash[zone.inputs.values.uniq.map { |input| [input.name, input.as_json] }]
+      {
+        inputs: inputs
+      }.to_json
+    end
+
+    get '/zones/:zone/inputs/:input' do
+      content_type :json
+      zone = remote.zone(params[:zone].to_i)
+      input = zone.inputs[params[:input]]
+
+      unless input
+        status 404
+        return {error: '404'}.to_json
+      end
+
+      input.as_json.to_json
+    end
+
+    post '/zones/:zone/inputs/:input/activate' do
+      zone = remote.zone(params[:zone].to_i)
+      input = zone.inputs[params[:input]]
+
+      unless input
+        status 404
+        content_type :json
+        return {error: '404'}.to_json
+      end
+
+      input.activate!
+
+      status 204
+      ''
+    end
+
+    get '/zones/:zone/active' do
+      content_type :json
+      zone = remote.zone(params[:zone].to_i)
+      zone.active_input.as_json.to_json
+    end
+
+    put '/zones/:zone/active' do
+      content_type :json
+
+      zone = remote.zone(params[:zone].to_i)
+      json_params = if request.content_type == 'application/json'
+                JSON.parse(request.body.read)
+              else
+                {}
+              end
+      query = json_params['input'] || params[:input]
+      input = zone.inputs[query]
+
+      unless input
+        pattern = Regexp.new(query, 'i')
+        input = zone.inputs.values.uniq.find { |_| pattern === _.name }
+      end
+
+      unless input
+        status 400
+        return {error: 'no input found'}.to_json
+      end
+
+      input.activate!
+
+      status 200
+      {input: input.as_json}.to_json
+    end
+
+    get '/zones/:zone/volume' do
+      content_type :json
+      zone = remote.zone(params[:zone].to_i)
+
+      {
+        zone: params[:zone],
+        volume: zone.volume,
+        mute: zone.muted?,
+        headphone: zone.headphone?,
+      }.to_json
+    end
+
+    put '/zones/:zone/volume' do
+      zone = remote.zone(params[:zone].to_i)
+      json_params = if request.content_type == 'application/json'
+                JSON.parse(request.body.read)
+              else
+                {}
+              end
+
+      volume = json_params['volume'] || params[:volume]
+      if volume
+        volume = volume.to_i
+        if max_volume && (max_volume < volume)
+          content_type :json
+          status 400
+          return {error: "over max volume #{max_volume}, given #{volume}"}.to_json
+        end
+
+        zone.volume = volume
+      end
+
+      mute = json_params.key?('mute') ? json_params['mute'] : params[:mute]
+      unless mute.nil?
+        p mute
+        zone.mute = mute
+      end
+
+      status 204
+    end
+  end
+end

data/lib/str_dn_2030/zone.rb

@@ -0,0 +1,58 @@
+module StrDn2030
+  class Remote
+    class Zone
+      def initialize(parent, zone_id, volume_type = "\x03".b)
+        @parent = parent
+        @zone_id = zone_id
+        @zone = zone_id.chr('ASCII-8BIT').freeze
+        @volume_type = volume_type.dup.b.freeze
+      end
+
+      attr_reader :parent, :zone_id, :zone, :volume_type
+      alias id zone_id
+
+      def reload
+        parent.reload; self
+      end
+
+      def inputs
+        parent.inputs[zone_id]
+      end
+
+      def powered_on?
+        parent.status_get(zone_id)[:flags][:power]
+      end
+
+      def muted?
+        parent.status_get(zone_id)[:flags][:mute]
+      end
+
+      def mute=(other)
+        parent.mute_set(zone_id, other)
+      end
+
+      def headphone?
+        parent.status_get(zone_id)[:flags][:headphone]
+      end
+
+      def volume
+        parent.volume_get(zone_id, volume_type)[:volume]
+      end
+
+      def volume=(other)
+        parent.volume_set(zone_id, other, volume_type)
+      end
+
+      def active_video
+        parent.active_input_get(zone_id)
+      end
+
+      def active_video=(other)
+        parent.active_input_set(zone_id, other)
+      end
+
+      alias active_input  active_video
+      alias active_input= active_video=
+    end
+  end
+end

data/str_dn_2030.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'str_dn_2030/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "str_dn_2030"
+  spec.version       = StrDn2030::VERSION
+  spec.authors       = ["Shota Fukumori (sora_h)"]
+  spec.email         = ["her@sorah.jp"]
+  spec.summary       = %q{Control your STR-DN-2030}
+  spec.description   = %q{Control STR-DN-2030 via TCP.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.6"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: str_dn_2030
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shota Fukumori (sora_h)
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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'
+description: Control STR-DN-2030 via TCP.
+email:
+- her@sorah.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- config.ru
+- lib/str_dn_2030.rb
+- lib/str_dn_2030/input.rb
+- lib/str_dn_2030/version.rb
+- lib/str_dn_2030/web.rb
+- lib/str_dn_2030/zone.rb
+- str_dn_2030.gemspec
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Control your STR-DN-2030
+test_files: []