trigger_switch_d 0.1.1 → 0.1.2

data/lib/tellstick/protocol/rising_sun.rb

@@ -16,6 +16,7 @@
 
 
 require File.join(File.dirname(__FILE__),"protocol_loader")
+require File.join(File.dirname(__FILE__),"..","code_converter")
 
 module Tellstick
   module RisingSun #:nodoc:
@@ -30,12 +31,15 @@ module Tellstick
       @output
     end
     private
+    
+    attr_reader :convert_it
+    def convert_it
+      @convert_it ||= CodeConverter.new([/[1234]/,/[A-D]/,/[a-d]/],-1)
+    end
+    
     def codify(code)
-      tmp_code = ((code =~ /[1234]/) == 0) ? code.to_i - 1: 0
-      tmp_code = code[0]-"A"[0] if ((code =~ /[A-D]/) == 0)      
-      tmp_code = code[0]-"a"[0] if ((code =~ /[a-d]/) == 0)
       result = ["e..e", "e..e", "e..e", "e..e"]
-      result[tmp_code] = ".e.e"
+      result[convert_it.to_i(code)] = ".e.e"
       result
     end
   end

data/lib/tellstick/proxy_io.rb

@@ -15,44 +15,62 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 module Tellstick
-  
+  #Proxy between usb dongle and driver
   class ProxyIO #:nodoc:all
     public
     def initialize(klass,*args)
       @init_args = args
       @class_to_proxy = klass
       @tio = nil
-      open
+      # open
+    end
+    
+    def method_missing(method_id)
+      @tio.send(method_id)
     end
+    
     def open
       return unless @tio == nil
-      if (@init_args.empty?)
-        @tio = @class_to_proxy.new
-      else
-        @tio = @class_to_proxy.new(@init_args[0],@init_args[1])
-        @init_args[2].call(@tio)
-      end
-      if @tio.methods.include?("connected?")
-        def self.connected?
-          open
-          @tio.connected?
-        end
-      end
+      create_io_instance
+      attach_connected
       return if @tio.private_methods.include?("open")
       @tio.open
     end
+    
     def close
       @tio.close unless @tio == nil
       @tio = nil
     end
+    
     def puts(input)
       open
       @tio.puts(input)
     end
+    
     def gets
       open
       @tio.gets
     end
+    
+    private
+    
+    def create_io_instance
+      if (@init_args.empty?)
+        @tio = @class_to_proxy.new
+      else
+        @tio = @class_to_proxy.new(@init_args[0],@init_args[1])
+        @init_args[2].call(@tio)
+      end
+    end
+    
+    def attach_connected
+      if @tio.methods.include?("connected?")
+        def self.connected?
+          open
+          @tio.connected?
+        end
+      end
+    end
   end
 end
 

data/lib/tellstick/tellstick.rb

@@ -57,17 +57,9 @@ module Tellstick
     not output.methods.include?("connected?")
   end
   def self.load(name)
-    $protocol ||= {}
-    protocol = $protocol[name]
-    if protocol == nil
-      filename = File.join(File.dirname(__FILE__),"protocol",name)
-      if File.exists?("#{filename}.rb")
-        require filename
-        protocol = $protocol[name]
-      else
-        protocol = NullProtocol
-      end
-    end
-    protocol
+    $protocol ||= Hash.new(NullProtocol)
+    filename = File.join(File.dirname(__FILE__),"protocol",name)
+    require filename if File.exists?("#{filename}.rb")
+    return $protocol[name]
   end
 end

data/lib/trigger_switch_d/action.rb

@@ -29,28 +29,27 @@ module TriggerSwitchD
       @at_location = environment[:at_location]
       @lookup = environment[:lookup]
       tokens = code_line.scan(/(\w+) (\w+) (\w+) ([\w\d:]+)/u).flatten
-      (class << self;self;end).methodize_device(tokens[1],devices[tokens[1]],@lookup) if devices.include? tokens[1]
-      code = tokens.map do |token|
-        (@lookup.include? token) ? @lookup[token] : token
-      end.reverse
-      @at, executable = send(code[3], send(code[2], send(code[1], code[0])))
-      (class << self;self;end).methodize_executable(executable)
+      ghost = (class << self;self;end)
+      ghost.methodize_device(tokens[1],devices,@lookup)
+      @at, executable = __build_executable_at__(tokens)
+      ghost.methodize_executable(executable)
     end
     
     def activate(*args) #:nodoc:
-      action(args[0][0],args[0][1],:turn_on)
+      Action.action(:turn_on,*args)
     end
     
     def deactivate(*args) #:nodoc:
-      action(args[0][0],args[0][1],:turn_off)
+      Action.action(:turn_off,*args)
     end
     
     def at(*args) #:nodoc:
-      return @at if args[0] == nil
-      if (args[0] =~ /(?:2[0-3]|[01]\d):[0-5]\d/) == 0
-        return args[0]
+      time = *args
+      return @at if time == nil
+      if (time =~ /(?:2[0-3]|[01]\d):[0-5]\d/) == 0
+        return time
       end
-      return @date.extend(Daylight).send(args[0],@at_location).localtime.strftime("%H:%M")
+      at_calculated_time(*args)
     end
     
     def to_s
@@ -59,24 +58,60 @@ module TriggerSwitchD
     
     private
     
-    def action(*args)
-      switches, at_time, event = args
+    def __build_executable_at__(tokens)
+      code = __translate__(tokens).reverse
+      code[1..3].inject(code[0]) do |part,val|
+        send(val, *part)
+      end
+    end
+    
+    def __translate__(tokens)
+      tokens.map do |token|
+        (@lookup.include? token) ? @lookup[token] : token
+      end
+    end
+    
+    def at_calculated_time(*args) #:nodoc:
+      method_name = *args
+      @date.extend(Daylight)
+      time = @date.send(method_name,@at_location)
+      time.localtime.strftime("%H:%M")
+    end
+
+    def self.action(*args)
+      event, switches, at_time = *args
+      call_args = Action.__build_action_args__(event,switches)
       code = Proc.new do |output|
-        switches.each do |switch|
-          Tellstick::create(output,switch.model_name).send(event,switch.house_code, switch.unit_code)
-        end
+        Action.__action_gut__(output,*call_args)
       end
       [at_time,code]
     end
     
+    def self.__build_action_args__(event,switches)
+      switches.map do |switch|
+        switch_array = switch.to_a_by_keys(%w{model_name house_code unit_code})
+        switch_array.insert(1,event)
+        switch_array
+      end
+    end
+    
+    def self.__action_gut__(*args)
+      args.each do |stick_call|
+        output, model_name, *params = args.flatten
+        Tellstick::create(output,model_name).send(*params)
+      end
+    end
+    
     def self.methodize_executable(executable)
       define_method(:execute,&executable)
     end
     
-    def self.methodize_device(name,switches,lookup)
+    def self.methodize_device(name,devices,lookup)
+      return unless devices.include? name
       lookup[name] = :remote_device.to_s
       define_method(:remote_device) do |*args|
-        [switches,args[0]]
+        time = *args
+        [devices[name],time]
       end
     end
   end

data/lib/trigger_switch_d/application.rb

@@ -36,32 +36,16 @@ module TriggerSwitchD
       logger.info("Environment prepared")
     end
     
+    ANYTHING_STR = "anything"
+    RESPONSE_STR = "response"
+    RECEIVED_STR = "received"
     #Runs the daemon untill process killed or it receives
     #stop from client connected via unix socket
     def start
-      com_thread = IPC.create(Config.unix_socket_path)
-      logger.info("IPC started")
-      com_thread["received"] = "anything"
-      while ((command = com_thread["received"].to_sym) != :stop)
-        now_time = Time.new
-        load_db(now_time.strftime("%Y-%m-%d %H:%M:%S"))
-        hhmm_now_time = now_time.strftime("%H:%M")
-        if methods.include? command.to_s
-          com_thread["response"] = send(command).to_yaml
-          logger.info("Received #{command} via IPC")
-          Config.log_object.flush
-          com_thread["received"] = "anything"
-          com_thread.run
-        end
-        if (schedule.cronological.keys.include? hhmm_now_time)
-          logger.info("Executed #{schedule.cronological[hhmm_now_time].length} action(s) at #{hhmm_now_time}")
-          Config.log_object.flush
-          schedule.execute(hhmm_now_time,Config.output)
-        end
-        Kernel.sleep(1)
-        com_thread["received"] = "anything" if com_thread["received"] == ""
-      end
-      logger.info("Received #{command} via IPC")
+      @ipc = IPC.create(Config.unix_socket_path)
+      @logger.info("IPC started")
+      __run_loop__
+      @logger.info("Received stop via IPC")
     end
     
     def list_schedule #:nodoc:
@@ -70,19 +54,78 @@ module TriggerSwitchD
 
     private
     
-    def load_db(time)
-      date = Date.parse(time)
-      return unless @current_date < date
-      file = File.open(Config.db_path[0],"r")
-      @devices = TriggerSwitchD::load_devices(file)
-      file.close
+    def load_db_at(time)
+      return unless did_set_current_date?(time)
+      load_db
+      logger.info("Loaded #{devices.length} devices and #{schedule.by_name.length} actions")
+      Config::flush_log
+    end
+    
+    def did_set_current_date?(time)
+      date = Date.parse(time.strftime("%Y-%m-%d %H:%M:%S"))
+      set_current_date = (@current_date != date)
+      @current_date = date if set_current_date
+      set_current_date
+    end
+    
+    def load_db
       @schedule = Schedule.create
-      file = File.open(Config.db_path[1],"r")
-      TriggerSwitchD::load_scheduled_actions(file,@schedule,devices,Config.environment)
+      Application.load_db_file(:devices) { |file| @devices = TriggerSwitchD::load_devices(file) }
+      inner_block = Proc.new do |code_line, date| 
+        @schedule.schedule_action(Action.new(code_line,devices,Config.environment,date))
+      end
+      Application.load_db_file(:schedule) do |file| 
+        TriggerSwitchD::load_scheduled_actions(file,&inner_block) 
+      end
+    end
+    
+    def self.load_db_file(filename_symbol)
+      lookup = {:devices => 0, :schedule => 1}
+      file = File.open(Config.db_path[lookup[filename_symbol]],"r")
+      yield(file)
       file.close
-      logger.info("Loaded #{devices.length} devices and #{schedule.by_name.length} actions")
-      Config.log_object.flush
-      @current_date = date
+    end
+    
+    def received
+      result = @ipc[RECEIVED_STR]
+      return result if result != ""
+      reset_received
+      ANYTHING_STR
+    end
+    
+    def reset_received
+      @ipc[RECEIVED_STR] = ANYTHING_STR
+    end
+    
+    def __run_loop__
+      command = ANYTHING_STR
+      while ((command = received).to_sym != :stop)
+        __inner_run_loop__(command)
+        Kernel.sleep(1)
+      end
+    end
+    
+    def __inner_run_loop__(command)
+      now_time = Time.new
+      load_db_at(now_time)
+      __respond_to_ipc__(command) if methods.include? command
+      __execute_action__(now_time.strftime("%H:%M"))
+    end
+    
+    def __respond_to_ipc__(command)
+      @ipc[RESPONSE_STR] = send(command).to_yaml
+      logger.info("Received #{command} via IPC")
+      Config::flush_log
+      reset_received
+      @ipc.run
+    end
+    
+    def __execute_action__(hhmm_now_time)
+      cronolog = @schedule.cronological
+      return unless (cronolog.keys.include? hhmm_now_time)
+      logger.info("Executed #{cronolog[hhmm_now_time].length} action(s) at #{hhmm_now_time}")
+      Config::flush_log
+      @schedule.execute(hhmm_now_time,Config.output)
     end
         
   end

data/lib/trigger_switch_d/config.rb

@@ -17,71 +17,121 @@ require "serialport"
 
 module TriggerSwitchD
   module ConfigFactory
-    ENV_PATH = "config/environment.rb"
+    
+    #Verifies proper path to environment.rb
+    class ProperEnvironmentFile
+      def initialize
+        @paths_to_look = %w{~/.trigger_switch_d/config/ /etc/trigger_switch_d/config/ config/}
+        @paths_to_look[0].gsub!("~",File.expand_path("~"))
+        @env_name = "environment.rb"
+      end
+      
+      def path
+        env_path = @paths_to_look.find do |path|
+          File.exist?("#{path}#{@env_name}")
+        end
+        return offer_to_create if env_path == nil
+        "#{env_path}#{@env_name}"
+      end
+      
+      private
+      def offer_to_create
+        return "" if ask == false
+        create
+        "#{@paths_to_look[0]}#{@env_name}"
+      end
+      
+      def create
+        home_path = @paths_to_look[0]
+        Kernel.system("mkdir -p #{home_path}")
+        Kernel.system("cp samples/environment.rb #{home_path}#{@env_name}")
+      end
+      
+      def ask
+          question = <<-EOS
+        Could't find the environment.rb file. I would like to create one for you at
+        #{@paths_to_look[0]} , do you want me to do that now [Yn]?
+          EOS
+          STDOUT.puts question
+          (STDIN.gets =~ /[nN]/) == nil
+      end
+      
+    end
     
     #Creates the Config class from the config/config.rb file
     #See samples/config.rb for more documentation
     def self.new(file=StringIO.new)
       env = file.readlines
-      attributes = env.map do |attribute|
-        attribute.scan(/Config.([\w_]+) =/).flatten[0]
-      end
-      attributes.compact!
-      cls = <<-EOS
-      class Config
-         #{attributes.map {|name| "def self.#{name}=(value); #{append_filenames(name)}; end"}.join("\n")}
-         
-         #{attributes.map {|name| "def self.#{name}; @#{name}; end"}.join("\n")}
-         
-         def self.default_environment
-           {:lookup => {"tänd" => "activate", 
-                     "släck" => "deactivate", 
-                     "soluppgång" => "sunrise", 
-                     "solnedgång" => "sunset",
-                     "klockan" => "at",
-                     "vid" => "at"},
-           :at_location => {:north => 0.0, :west => 0.0}}
-         end
-      end
-      EOS
-      ::TriggerSwitchD.module_eval(cls)
+      attributes = map_attributes(env)
+      eval_config_code_definition(attributes)
       setup_environment(env)
     end
     
     private
+    def self.map_attributes(env_list)
+      env_list.map do |attribute|
+        attribute.scan(/Config.([\w_]+) =/).flatten[0]
+      end.compact
+    end
+    
     def self.setup_environment(env)
       env.map do |attribute|
         ::TriggerSwitchD.module_eval(attribute)
       end
       def Config.environment
         result = default_environment
-        file = File.open(Config.dsl_path,"r")
-        result[:lookup] = YAML::load(file)
-        file.close
+        File.open(Config.dsl_path,"r") do |file|
+          result[:lookup] = YAML::load(file)
+        end
         result[:at_location] = Config.geo_position
         result
       end
     end
 
     def self.set_type(name)
-      types = {"log_object" => "{:spec => StringIO.new, :development => STDOUT, 
-                                  :file => File.open(\"#log_path}\",\"a+\")}",
+      types = {"log_object" => "Hash.new(STDOUT).merge({:spec => StringIO.new, :development => STDOUT, 
+                              :file => Tellstick::ProxyIO.new(File,Config.log_path,\"a+\",Proc.new { })})",
                 "output" => "Hash.new(STDOUT).merge({:spec => StringIO.new, :development => STDOUT, 
                               :vcp => Tellstick::ProxyIO.new(SerialPort,Config.vcp_port,4800,Proc.new { |sp| sp.puts(\"~^M~AT S7=45 S0=0 L1 V1 X4 &c1 E1 Q0^M\"); sp.puts(\"S+\"); sp.gets })})"}
       return "@#{name}=value" unless types.keys.include? name
-      "@#{name}=#{types[name]}[value]".gsub("log_path","{log_path")
+      "@#{name}=#{types[name]}[value]"#.gsub("log_path","{log_path")
     end
 
+    PATH_FILENAMES = {"log_path" => ["tsd.log"], "db_path" => ["devices","scheduled_actions"],
+                 "dsl_path" => ["lookup.dsl"], "unix_socket_path" => ["com.adhocskill.trigger_switch_d"]}
+
     def self.append_filenames(name)
-      filenames = {"log_path" => ["tsd.log"], "db_path" => ["devices","scheduled_actions"],
-                   "dsl_path" => ["lookup.dsl"], "unix_socket_path" => ["com.adhocskill.trigger_switch_d"]}
-      return set_type(name) unless filenames.keys.include? name
-      result = filenames[name].map do |fname|
+      return set_type(name) unless PATH_FILENAMES.keys.include? name
+      filename = PATH_FILENAMES[name]
+      result = filename.map do |fname|
         "#value}/#{fname}"
-      end.inspect.gsub("value","{value")
-      result = result.gsub("[","").gsub("]","") if filenames[name].length == 1
+      end.inspect.gsub("value}","value.gsub(\"~\",File.expand_path(\"~\"))}").gsub("value","{value")
+      result = result.gsub("[","").gsub("]","") if filename.length == 1
       "@#{name}=#{result}"
     end
+    
+    def self.eval_config_code_definition(attributes)
+      cls = <<-EOS
+      class Config
+         #{attributes.map {|name| "def self.#{name}=(value); #{append_filenames(name)}; end; ; def self.#{name}; @#{name}; end "}.join("\n")}
+         
+         def self.default_environment
+           {:lookup => {"tänd" => "activate", 
+                     "släck" => "deactivate", 
+                     "soluppgång" => "sunrise", 
+                     "solnedgång" => "sunset",
+                     "klockan" => "at",
+                     "vid" => "at"},
+           :at_location => {:north => 0.0, :west => 0.0}}
+         end
+         
+         def self.flush_log
+           log_object.flush
+         end
+      end
+      EOS
+      ::TriggerSwitchD.module_eval(cls)
+    end
   end
 end