frypan 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fb8a7b23f1048487bc5ab065783383c02ce47b1d
+  data.tar.gz: 93c85039222d259ad54acab69dadb06e653811f6
+SHA512:
+  metadata.gz: 7af33ae5164675458049fd5be4bc2c7ca67333ca1ca4dd6e525e6575074c905367d092383a5c4bdde9d53269494c76ff8335aa2f86215a86accc1f0152df47df
+  data.tar.gz: c52cf2274ac18309bf4ecbc09164511dcba3ec2149fb5fd118713f1e66828d78631be153de21a29516920cb1bd1a3d4857e23b581b34bc2b4fbb542fa88adc1a

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*~
+*#
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 TODO: Write your name
+
+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/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |test|
+  test.test_files = Dir["unit_test/**/test_*.rb"]
+  test.verbose = true
+end
+

data/_README.md

@@ -0,0 +1,31 @@
+# Frypan
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'frypan'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install frypan
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/frypan/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/bin/frypan

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+# -*- mode: ruby -*-
+
+require 'mongo'
+
+def install(home_path)
+  # 1. mongodbのバイナリを落として [homepath]/mongodb.tarに保存
+  # 2. 解凍する。[homepath]/mongodb/bin/mongodってな具合になる
+  # 3. [homepath]/db/作る
+end
+
+def fork_db(home_path, port=27017)
+  mongod = "#{home_path}/mongodb/bin/mongod"
+  db = "#{home_path}/db/"
+  log = "#{home_path}/db/server.log"
+  status = `#{mongod} --dbpath #{db} --logpath #{log} --port #{port} --fork`
+  pid = status.lines.map{|ln| ln.match(/forked process: (\d+)/)}.select{|a| a}.first[1].to_i
+  success = status.lines.any?{|ln| ln.match(/successfully/)}
+  if success then pid else nil end
+end
+
+def connect_db(port=27017, host="localhost")
+  Mongo::Connection.new(host, port).db("frypan_core")
+end
+
+begin
+  pid = fork_db("~/Workspace/")
+  TinyFRP::Runtime.new(main_signal(connect_db)).run(:loop)
+ensure
+  Process.kill("TERM", pid) if pid
+end
+
+
+
+db = hoge
+api_server = APIServer.new(db) # fork webrick. only op-command throw.
+epg = hoge
+tuner = [fuga]
+
+command = TinyFRP.lift{ api_server.get_next_command } # one-unit-command OR nil
+current_time = TinyFRP.lift{ Time.now.strftime("%Y%m%d%H%M%S") }
+epg_flag = hoge
+tuners_flag = [fuga]
+
+main = TinyFRP::Bundle.new(command, current_time, epg_flag, tuners_flag) >> Node.top(setting)
+
+TinyFRP.loop(main) do |out|
+  out[:reserve1].action(db)
+  out[:reserve2].action(db)
+  out[:reserve3].action(db)
+  out[:reserve4].action(db)
+  out[:epg].action(epg)
+  out[:tuner1].action(tuner1)
+end

data/frypan.gemspec

@@ -0,0 +1,24 @@
+# -*- mode: ruby -*-
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'frypan/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "frypan"
+  spec.version       = Frypan::VERSION
+  spec.authors       = ["sawaken"]
+  spec.email         = ["sasasawada@gmail.com"]
+  spec.summary       = %q{Yet another recording scheduler.}
+  spec.description   = %q{}
+  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.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/frypan/database_sync_list.rb

@@ -0,0 +1,30 @@
+module Frypan
+  class DBSyncList
+    def initialize(name, db)
+      @coll = db.collection(name)
+    end
+
+    def +(list)
+      list.each{|a| @coll.insert(a)}
+      self
+    end
+
+    def update(alt_list)
+      @coll.remove
+      alt_list.each{|a| @coll.insert(a)}
+      self
+    end
+
+    def update_elements(elements, ident_key)
+      elements.each do |a|
+        @coll.update({ident_key => a[ident_key]}, {"$set" => a}, true)
+      end
+      self
+    end
+
+    def to_a
+      @coll.find.to_a
+    end
+  end
+end
+

data/lib/frypan/epg_parser.rb

@@ -0,0 +1,23 @@
+module Frypan
+  class EpgParser
+    require 'm2ts_parser'
+    class ParserProcess
+      def initialize(file_path)
+        
+      end
+
+      def finished?
+
+      end
+
+      def get_parsed
+
+      end
+    end
+
+    def parse(file_path)
+      ParserProcess.new(file_path)
+    end
+  end
+end
+

data/lib/frypan/node.rb

@@ -0,0 +1,150 @@
+module Frypan
+  require 'tiny_frp'
+  module Node
+    def self.overlaped?(list_of_range)
+      !list_of_range.sort{|a, b| a.begin <=> b.begin}.each_cons(2).all?{|a, b| a.end <= b.begin}
+    end
+
+    def self.apply_operations(list, ops)
+      case
+      when ops == []
+        [list, ""]
+      when ops.first[:kind] == :add
+        added_list = list + [ops.first[:target]]
+        if overlaped?(added_list.map{|a| a[:start_time]..a[:end_time]})
+          [nil, "cannot add reservation: #{ops.first[:target]}"]
+        else
+          apply_operations(added_list, ops.drop(1))
+        end
+      when ops.first[:kind] == :remove
+        if list.find{|a| a[:start_time] == ops.first[:target][:start_time]}
+          apply_operations(list.reject{|a| a[:start_time] == ops.first[:target][:start_time]}, ops.drop(1))
+        else
+          [nil, "unexist remove reservation id: #{ops.first[:target][:id]}"]
+        end
+      else
+        [nil, "unknown operation '#{ops.first[:kind]}'"]
+      end
+    end
+
+    def self.ReserveListFoldp(tuner_id, initial_list=[])
+      TinyFRP.foldp(launch: nil, list: initial_list, ack: nil) do |acc, command, current_time|
+        case
+        when command && command[:target_tuner] == tuner_id
+          new_list, status = *apply_operations(acc[:list], command[:operations])
+          ack = command.merge({
+             timestamp: current_time,
+             succeeded: !!new_list,
+             status: status
+           })
+          if new_list
+            {launch: nil, list: new_list.sort{|a, b| a[:start_time] <=> b[:start_time]}, ack: ack}
+          else
+            {launch: nil, ack: ack}
+          end
+        when acc[:list] != [] && acc[:list].first[:start_time] <= current_time
+          {launch: acc[:list].first, list: acc[:list].drop(1), ack: nil}
+        else
+          {launch: nil, ack: nil}
+        end
+      end
+    end
+
+    def self.PersistantReserveListFoldp(tuner_id, dbsync_reserve)
+      TinyFRP.foldp(last_list: nil, list: dbsync_reserve) do |acc, rlist|
+        if !acc[:last_list] || acc[:last_list] != rlist[:list]
+          {last_list: rlist[:list], list: acc[:list].update(rlist[:list])}
+        else
+          {}
+        end
+      end
+    end
+
+    def self.RecordingAsyncFoldp(tuner)
+      TinyFRP.foldp(busy: false, rec_process: nil, waiting: [], log: []) do |acc, rlist|
+        case
+        when rlist[:launch]
+          {waiting: acc[:waiting] + [rlist[:launch]], log: []}
+        when acc[:busy]
+          {busy: !acc[:rec_process].finished?, log: acc[:rec_process].get_log}
+        when acc[:waiting] != []
+          {
+            busy:        true,
+            rec_process: tuner.rec(acc[:waiting].first),
+            waiting:     acc[:waiting].drop(1),
+            log:         []
+          }
+        else
+          {log: []}
+        end
+      end
+    end
+
+    def self.RecordingLogFoldp(initial_log=[])
+      TinyFRP.foldp(log: initial_log, epg_order: [], recorded: []) do |acc, *log_inputs|
+        if log_inputs.any?{|a| a != []}
+          new_logs = log_inputs.select{|a| a != []}.flatten
+          {
+            log:       acc[:log] + new_logs,
+            epg_order: Fnc.find_epg_order(new_logs),
+            recorded:  Fnc.find_recorded(new_logs)
+          }
+        else
+          {epg_order: [], recorded: []}
+        end
+      end
+    end
+
+    def self.EpgExtractAsyncFoldp(epg_parser)
+      TinyFRP.foldp(busy: false, parser_process: nil, waiting: [], extracted: []) do |acc, log|
+        case
+        when log[:epg_order]
+          {waiting: acc[:waiting] + [log[:epg_order]], extracted: []}
+        when acc[:busy]
+          {busy: !acc[:parser_process].finished?, extracted: acc[:parser_process].get_parsed}
+        when acc[:waiting] != []
+          {
+            busy:           true,
+            parser_process: epg_parser.parse(acc[:waiting].first[:file_path]), 
+            waiting:        acc[:waiting].drop(1),
+            extracted:      []
+          }
+        else
+          {extracted: []}
+        end
+      end
+    end
+
+    def self.ProgramListFoldp(initial_list=[])
+      TinyFRP.foldp(list: initial_list) do |acc, epg|
+        if epg[:extracted] != []
+          # epg[:extracted] := list of {program_id: [service_id, event_id], ...}
+          {list: acc[:list].update_elements(epg[:extracted], :program_id)}
+        else
+          {}
+        end
+      end
+    end
+
+    def self.RecordedListFoldp(initial_list=[])
+      TinyFRP.foldp(list: initial_list) do |acc, log|
+        if log[:recorded] != []
+          {list: acc[:list] + log[:recorded]}
+        else
+          {}
+        end
+      end
+    end
+
+    def self.UIresponseFoldp(initial_list=[])
+      TinyFRP.foldp(list: initial_list) do |acc, current_time, *acks|
+        if acks.any?{|a| a}
+          {list: acc[:list] + acks.select{|a| a}}
+        else
+          {}
+        end
+      end
+    end
+  end
+end
+

data/lib/frypan/tuner.rb

@@ -0,0 +1,47 @@
+module Frypan
+  class Tuner
+    class RecordingProcess
+      def initialize(command)
+        @reader, writer = IO.pipe
+        @pid = Process.spawn(command, :err => writer, :out => writer)
+        @mutex = Mutex.new
+        @logs = []
+        Thread.new{
+          while IO::select([@reader])
+            @mutex.synchronize{
+              @logs << @reader.gets.chomp
+            }
+          end
+        }
+      end
+
+      def finished?
+        @finished ||= Process.waitpid2(@pid, Process::WNOHANG)
+      end
+
+      def get_log
+        res = []
+        @mutex.synchronize{
+          res = @logs.dup
+          @logs = []
+        }
+        res
+      end
+    end
+
+    def initialize(format_str)
+      @format_str = format_str
+    end
+
+    def rec(setting)
+      RecordingProcess.new(Tuner.make_command(@format_str, setting))
+    end
+
+    def self.make_command(format_str, setting)
+      setting.keys.inject(format_str) do |str, key|
+        str.gsub("<#{key}>", setting[key].to_s)
+      end
+    end
+  end
+end
+

data/lib/frypan/version.rb

@@ -0,0 +1,3 @@
+module Frypan
+  VERSION = "0.0.1"
+end

data/lib/frypan.rb

@@ -0,0 +1,57 @@
+require "frypan/version"
+
+module Frypan
+  # TODO
+  #  imp APIServer
+  #  imp EpgParser
+
+  def self.main_signal(db, tuner_config=nil)
+    dbsync_ui_res        = DBSyncList.new("ui_response",   db)
+    dbsync_recording_log = DBSyncList.new("recording_log", db)
+    dbsync_program       = DBSyncList.new("program",       db)
+    dbsync_recorded      = DBSyncList.new("recorded",      db)
+
+    dbsync_reserve1 = DBSyncList.new("reserve1", db)
+    dbsync_reserve2 = DBSyncList.new("reserve2", db)
+    dbsync_reserve3 = DBSyncList.new("reserve3", db)
+    dbsync_reserve4 = DBSyncList.new("reserve4", db)
+
+    api_server = APIServer.new(db) # fork webrick. only op-command throw.
+
+    command = TinyFRP.lift{ api_server.get_next_command } # one-unit-command OR nil
+    #com = {
+    #  command_id: 1024,
+    #  target_tuner: 1
+    #  operations: [
+    #               {:kind => :remove, ::target => {reserve data (something including start_time)}},
+    #               {:kind => :add,    :target => {reserve data}}
+    #              ]
+    #}
+      
+    current_time = TinyFRP.lift{ Time.now.strftime("%Y%m%d%H%M%S") }
+
+    s1 = TinyFRP.bundle(command, current_time) >> Node.ReserveListFoldp("tuner1", dbsync_reserve1.to_a)
+    s2 = TinyFRP.bundle(command, current_time) >> Node.ReserveListFoldp("tuner2", dbsync_reserve2.to_a)
+    s3 = TinyFRP.bundle(command, current_time) >> Node.ReserveListFoldp("tuner3", dbsync_reserve3.to_a)
+    s4 = TinyFRP.bundle(command, current_time) >> Node.ReserveListFoldp("tuner4", dbsync_reserve4.to_a)
+
+    ui_res = Node.UIresponseFoldp(dbsync_ui_res) <<  TinyFRP.bundle(s1, s2, s3, s4)
+
+    ps1 = s1 >> Node.PersistantReserveListFoldp("tuner1", dbsync_reserve1)
+    ps2 = s2 >> Node.PersistantReserveListFoldp("tuner2", dbsync_reserve2)
+    ps3 = s3 >> Node.PersistantReserveListFoldp("tuner3", dbsync_reserve3)
+    ps4 = s4 >> Node.PersistantReserveListFoldp("tuner4", dbsync_reserve4)
+
+    t1 = s1 >> Node.RecordingAsyncFoldp(Tuner.new("fmt1"))
+    t2 = s2 >> Node.RecordingAsyncFoldp(Tuner.new("fmt2"))
+    t3 = s3 >> Node.RecordingAsyncFoldp(Tuner.new("fmt2"))
+    t4 = s4 >> Node.RecordingAsyncFoldp(Tuner.new("fmt2"))
+
+    recording_log = TinyFRP.bundle(t1, t2, t3, t4) >> Node.RecordingLogFoldp(dbsync_recording_log)
+    epg_extract   = recording_log >> Node.EpgExtractAsyncFoldp(EpgParser.new)
+    program_list  = epg_extract >> Node.ProgramListFoldp(dbsync_program)
+    recorded_list = recording_log >> Node.RecordedListFoldp(dbsync_recorded)
+
+    return TinyFRP.bundle(ui_res, ps1, ps2, ps3, ps4, program_list, recorded_list) >> TinyFRP.bottom
+  end
+end

data/unit_test/test_node.rb

@@ -0,0 +1,171 @@
+$LIBRARY_ROOT_PATH = File.dirname(File.expand_path(File.dirname(__FILE__)))
+
+module Frypan
+  module UnitTest
+    require 'test/unit'
+    require $LIBRARY_ROOT_PATH + '/lib/frypan/node.rb'
+
+    class DummyList
+      attr_reader :array
+      def initialize(init=[])
+        @array = []
+      end
+
+      def +(list)
+        DummyList.new(@array + list)
+      end
+
+      def update(alt_list)
+        DummyList.new(alt_list)
+      end
+
+      def update_elements(elements, ident_key)
+        if elements == []
+          self
+        else
+          update_element(elements.first, ident_key).update_elements(elements.drop(1), ident_key)
+        end
+      end
+
+      def update_element(element, ident_key)
+        if @array.find{|a| a[ident_key] == element[ident_key]}
+          DummyList.new(@array.map{|a| a[ident_key] == element[ident_key] ? element : a})
+        else
+          DummyList.new(@array + [element])
+        end
+      end
+    end
+
+    class DummyTuner
+      class DummyRecordingProcess
+        def initialize(logs)
+          @logs = logs.dup
+        end
+
+        def finished?
+          @logs.empty?
+        end
+        
+        def get_log
+          @logs.shift || []
+        end
+      end
+
+      def initialize(logs)
+        @logs = logs
+      end
+
+      def rec(setting)
+        DummyRecordingProcess.new(@logs)
+      end
+    end
+
+    class DummyEpgParser
+      class DummyParserProcess
+        def initialize(parseds)
+          @parseds = parseds.dup
+        end
+
+        def finished?
+          @parseds.empty?
+        end
+
+        def get_parsed
+          @parseds.shift || []
+        end
+      end
+
+      def initialize(parseds)
+        @parseds = parseds
+      end
+
+      def parse(file_path)
+        DummyParserProcess.new(@parseds)
+      end
+    end
+
+    module Util
+      def mkcom(command_id, target_tuner, *ops)
+        {command_id: command_id, target_tuner: target_tuner, operations: ops}
+      end
+
+      def mkop(kind, target)
+        {kind: kind, target: target}
+      end
+      
+      def mkres(id, start_time, end_time)
+        {id: id, start_time: start_time, end_time: end_time}
+      end
+    end
+
+    class NodeTest < Test::Unit::TestCase
+      include Util
+
+      def test_ReserveListFoldp
+        n = Node.ReserveListFoldp(:test_tuner, [])
+        vals = [
+                nil,
+                com1 = mkcom(0, :test_tuner, mkop(:add, res1 = mkres(0, 2, 5))),
+                com2 = mkcom(1, :test_tuner, mkop(:add, res2 = mkres(1, 5, 7))),
+                nil,
+                com3 = mkcom(2, :test_tuner, mkop(:add, res3 = mkres(2, 6, 10)))
+               ].each_with_index.map{|a, i| n.call(a, i)}
+
+        assert_equal({launch: nil, list: [], ack: nil}, vals[0])
+
+        expect_ack1 = com1.merge(timestamp: 1, succeeded: true, status: "")
+        assert_equal({launch: nil,  list: [res1], ack: expect_ack1}, vals[1])
+
+        expect_ack2 = com2.merge(timestamp: 2, succeeded: true, status: "")
+        assert_equal({launch: nil, list: [res1, res2], ack: expect_ack2}, vals[2])
+
+        assert_equal({launch: res1,  list: [res2], ack: nil}, vals[3])
+
+        expect_ack3 = com3.merge(timestamp: 4, succeeded: false, status: vals[4][:ack][:status])
+        assert_equal({launch: nil, list: [res2], ack: expect_ack3}, vals[4])
+      end
+
+      def test_PersistantReserveListFoldp
+        n = Node.PersistantReserveListFoldp(:tuner_tuner, DummyList.new([]))
+        vals = [
+                {list: [:a]},
+                {list: [:a]},
+                {list: [:a, :b]},
+               ].map{|a| n.call(a)}
+
+        assert_equal(vals[0], vals[1])
+        assert_not_equal(vals[1], vals[2])
+      end
+
+      def test_RecordingAsyncFoldp
+        n = Node.RecordingAsyncFoldp(DummyTuner.new([[0, 1], [2]]))
+        v = [
+             {launch: nil},
+             {launch: :a},
+             {launch: nil},
+             {launch: :b},
+             {launch: nil},
+             {launch: nil},
+             {launch: nil},
+             {launch: nil},
+             {launch: nil},
+             {launch: nil},
+             {launch: nil},
+            ].map{|a| n.call(a)}
+
+        assert_equal({busy: false, rec_process: v[0][:rec_process],  waiting: [],   log: []},     v[0])
+        assert_equal({busy: false, rec_process: v[1][:rec_process],  waiting: [:a], log: []},     v[1])
+        assert_equal({busy: true,  rec_process: v[2][:rec_process],  waiting: [],   log: []},     v[2])
+        assert_equal({busy: true,  rec_process: v[3][:rec_process],  waiting: [:b], log: []},     v[3])
+        assert_equal({busy: true,  rec_process: v[4][:rec_process],  waiting: [:b], log: [0, 1]}, v[4])
+        assert_equal({busy: true,  rec_process: v[5][:rec_process],  waiting: [:b], log: [2]},    v[5])
+        assert_equal({busy: false, rec_process: v[6][:rec_process],  waiting: [:b], log: []},     v[6])
+        assert_equal({busy: true,  rec_process: v[7][:rec_process],  waiting: [],   log: []},     v[7])
+        assert_equal({busy: true,  rec_process: v[8][:rec_process],  waiting: [],   log: [0, 1]}, v[8])
+        assert_equal({busy: true,  rec_process: v[9][:rec_process],  waiting: [],   log: [2]},    v[9])
+        assert_equal({busy: false, rec_process: v[10][:rec_process], waiting: [],   log: []},     v[10])
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: frypan
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- sawaken
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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'
+description: ''
+email:
+- sasasawada@gmail.com
+executables:
+- frypan
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- Rakefile
+- _README.md
+- bin/frypan
+- frypan.gemspec
+- lib/frypan.rb
+- lib/frypan/database_sync_list.rb
+- lib/frypan/epg_parser.rb
+- lib/frypan/node.rb
+- lib/frypan/tuner.rb
+- lib/frypan/version.rb
+- unit_test/test_node.rb
+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: Yet another recording scheduler.
+test_files: []