domotics-core 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d968d8308c24d08e2171654bc6845b5b76104fc
-  data.tar.gz: b2538a84593856978c5945464fb7efe00a2895d9
+  metadata.gz: 096e15387741c6806173272f0da0754df91249d7
+  data.tar.gz: 2555b1a6fd43f0d236edd53d94508072af6c6f10
 SHA512:
-  metadata.gz: a54f487cd28ee6cdf719838ac721b8c3064e8d71748b68dd6104d5c14fbe7bd6c9ea60dcecc9fdda253c3219effa0f391c272671e61a4604a71e745754c86522
-  data.tar.gz: ed4c64c3b9b1b2611445105f229c17d4a62d34cb84c9b8c13931bd22bad2cb407087484bbaf51468900588fb03731e4207b2a0d12ee80f034c06d94ac9915702
+  metadata.gz: 52e29d3445656f7a3b447687986a93e524652e1fa2439e875c36d741095d5863f81e91d1bd1a4ab9ff9333d10545e70bfb22864cdac3e5d9233147c5855cbc57
+  data.tar.gz: d390c82c1906c07a3744288481a2b18b6a8fc72219f05f3bad21968b9e236cc60cba0956a797fc0daf80866c38622244c1d49162849392a30626e4021bc804a4

data/Rakefile

@@ -36,7 +36,7 @@ end
 
 def update(msg)
   # Update version
-  File.open "./lib/domotics/arduino/version.rb", "r+" do |f|
+  File.open "./lib/domotics/core/version.rb", "r+" do |f|
     up = f.read.sub(/\d+.\d+.\d+/) { |ver| ver.split('.').map.with_index{ |sv, i| yield sv,i }.join('.') }
     f.seek 0
     f.write up
@@ -52,4 +52,4 @@ def update(msg)
   puts "Pushed to github."
   Dir["./*.gemspec"].each { |spec| puts %x(gem build #{spec}) }
   Dir["./*.gem"].each { |gem| puts %x(gem push #{gem}) }
-end
+end

data/lib/domotics/core.rb

@@ -1,7 +1,47 @@
-require "domotics/core/version"
+# From data_mongo
+require 'mongo'
+# From data_redis
+require 'redis'
+require 'hiredis'
+# From arduino_board
+require 'domotics/arduino'
+# From server
+require 'json'
 
 module Domotics
   module Core
-    # Your code goes here...
+    # Map config names to real classes
+    CLASS_MAP = {}
+    # Scan file for class name and add to CLASS_MAP
+    def self.add_map(args = {})
+      realm = args[:realm] || self
+      if args[:file]
+        class_name = nil
+        index = nil
+        require args[:file]
+        IO.read(args[:file]).each_line do |line|
+          if line =~ /class\s*([A-Z]\w*)[\s\w<]*(#__as__ :(\w*))?/
+            class_name, index = $1, $3 && $3.to_sym
+            break
+          end
+        end
+        return unless class_name
+      end
+      class_name ||= args[:class_name]
+      index ||= class_name.split(/(?=[A-Z])/).map{ |cnp| cnp.downcase }.join('_').to_sym
+      klass = realm.const_get(class_name)
+      CLASS_MAP[index] = [args[:type], klass]
+    end
+  end
+end
+
+gem_path = File.dirname(__FILE__)
+#require all
+Dir["#{gem_path}/core/data/*.rb"].each {|file| require file}
+Dir["#{gem_path}/core/*.rb"].each {|file| require file}
+# scan all devices and elements and populate class map
+[:device, :room, :element].each do |type|
+  Dir["#{gem_path}/core/#{type}/*.rb"].each do |file|
+    Domotics::Core.add_map type: type, file: file
   end
 end

data/lib/domotics/core/data/data_hash.rb

@@ -0,0 +1,38 @@
+module Domotics::Core
+  class DataHash
+    def initialize
+      @store = {}
+    end
+
+    def [](obj)
+      case obj
+      when Element
+        DataHashOperator.new self, "#{obj.room.name}:#{obj.name}"
+      end
+    end
+    
+    def set(key, value)
+      @store[key] = value
+    end
+    def get(key)
+      @store[key]
+    end
+  end
+
+  class DataHashOperator < BasicObject
+    def initialize(hash, key)
+      @hash, @key = hash, key
+    end
+
+    def method_missing(symbol, *args)
+      # Setter method [*=(value)]
+      if symbol.to_s =~ /.*=\Z/ and args.size == 1
+        @hash.set "#{@key}:#{symbol.to_s[0..-2]}", args[0]
+      elsif args.size == 0
+        @hash.get "#{@key}:#{symbol}"
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/domotics/core/data/data_mongo.rb

@@ -0,0 +1,39 @@
+module Domotics::Core
+  class DataMongo
+    def initialize(args = {})
+      @logger = args[:logger] || Logger.new(STDERR)
+      @mongo = Mongo::MongoClient.new(args[:host] || "127.0.0.1", args[:port] || 27017).db("domotics")
+    end
+
+    def [](obj)
+      case obj
+      when Element
+        DataMongoOperator.new @mongo.collection(obj.room.name.to_s), obj.name.to_s
+      end
+    end
+  end
+
+  class DataMongoOperator < BasicObject
+    def initialize(coll, element)
+      @coll = coll
+      @element = element
+    end
+
+    def method_missing(symbol, *args)
+      # Setter method [*=(value)]
+      if symbol.to_s =~ /.*=\Z/ and args.size == 1
+        if el = @coll.find_one("element" => @element)
+          @coll.update({ "_id" => el["_id"] }, { "element" => @element, symbol.to_s[0..-2] => args[0] })
+        else
+          @coll.insert("element" => @element, symbol.to_s[0..-2] => args[0])
+        end
+        # Getter method (no arguments allowed)
+      elsif args.size == 0
+        result = @coll.find_one("element" => @element)
+        result && result[symbol.to_s]
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/domotics/core/data/data_redis.rb

@@ -0,0 +1,56 @@
+module Domotics::Core
+  class DataRedis
+    def initialize(args = {})
+      @logger = args[:logger] || Logger.new(STDERR)
+      @args = Hash.new
+      @args[:host] = args[:host] || "127.0.0.1"
+      @args[:port] = args[:port] || 6379
+      @args[:driver] = :hiredis
+      connect
+    end
+
+    def [](obj)
+      case obj
+      when Element
+        DataRedisOperator.new self, "#{obj.room.name}:#{obj.name}"
+      end
+    end
+
+    def connect(args = {})
+      @logger.debug "Broken connection to redis host [#{@args[:host]}:#{@args[:port]}] detected. Reconnect." if args[:broken]
+      @redis.quit if @redis
+      @redis = Redis.new @args
+    end
+
+    def get(*args)
+      @redis.get *args
+    end
+    def set(*args)
+      @redis.set *args
+    end
+  end
+
+  class DataRedisOperator < BasicObject
+    def initialize(redis, key)
+      @redis = redis
+      @key = key
+    end
+
+    def method_missing(symbol, *args)
+      # Setter method [*=(value)]
+      if symbol.to_s =~ /.*=\Z/ and args.size == 1
+        @redis.set "#{@key}:#{symbol.to_s[0..-2]}", args[0].to_s
+      # Getter method (no arguments allowed)
+      elsif args.size == 0
+        result = @redis.get "#{@key}:#{symbol}"
+        while result =~ /\AOK\Z/
+          @redis.connect broken: true
+          result = @redis.get "#{@key}:#{symbol}"
+        end
+        result && result.to_isym
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/domotics/core/device.rb

@@ -0,0 +1,22 @@
+module Domotics::Core
+  class Device
+    @@devices = {}
+    attr_reader :name, :type
+    def initialize(args = {})
+      @@devices[@name = args[:name]] = self
+      @type = args[:type]
+    end
+
+    def self.[](symbol = nil)
+      return @@devices[symbol] if symbol
+      @@devices
+    end
+
+    def destroy
+      @@devices[@name] = nil
+    end
+    def to_s
+      "Room[#{@name}](id:#{__id__})"
+    end
+  end
+end

data/lib/domotics/core/device/arduino_board.rb

@@ -0,0 +1,37 @@
+module Domotics::Core
+  class ArduinoBoard < Device #__as__ :arduino
+    include Domotics::Arduino::ArduinoBase
+
+    def initialize(args_hash = {})
+      @pins = Hash.new
+      super
+    end
+
+    # Register pin for watch events
+    def register_pin(pin_object, number)
+      @pins[number] = pin_object
+    end
+
+    # Return pin object
+    def [](number = nil)
+      return @pins[number] if number
+      @pins
+    end
+
+    private
+
+    # Override default handler
+    def event_handler(hash)
+      case hash[:event]
+        # Tell element to change state
+      when :pin_state_changed
+        element = @pins[hash[:pin]]
+        element.state_changed element.to_hls(hash[:state])
+      when :malfunction
+        nil
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/domotics/core/element.rb

@@ -0,0 +1,47 @@
+module Domotics::Core
+  class Element
+    @@data = DataHash.new
+    attr_reader :name, :type, :room
+
+    def initialize(args = {})
+      @room = args[:room]
+      @room.register_element self, @name = args[:name]
+      @type ||= :element
+      set_state(self.state || :off)
+    end
+
+    def state
+      @@data[self].state
+    end
+
+    def verbose_state
+      { @room.name =>
+        { :elements =>
+          { @name =>
+            { :state => state,
+              :info => (info if respond_to? :info)
+            }
+          }
+        }
+      }
+    end
+
+    def set_state(value)
+      @@data[self].state = value
+      @room.notify({ event: :state_set, element: self }) unless @type == :dimmer
+    end
+
+    def state_changed(value)
+      @@data[self].state = value
+      @room.notify event: :state_changed, element: self
+    end
+
+    def self.data=(value)
+      @@data = value
+    end
+
+    def to_s
+      "Element[#{@room.name}@#{@name}](id:#{__id__})"
+    end
+  end
+end

data/lib/domotics/core/element/button.rb

@@ -0,0 +1,41 @@
+module Domotics::Core
+  class Button < Element
+    def initialize(args = {})
+      @type = args[:type] || :button
+      @touch = args[:touch]
+      @taped = true
+      #@tap_lock = Mutex.new
+      if args[:device_type]
+        eval_str = %(include Domotics::#{args[:device_type].capitalize}::#{@touch ? 'DigitalSensor' : 'NOSensor'})
+        self.class.class_eval(eval_str, __FILE__, __LINE__)
+      end
+      super
+    end
+    def set_state(*args)
+      nil
+    end
+
+    def state_changed(value)
+      case value
+      when :on
+        (@last_on = Time.now; @taped = false) if @taped
+      when :off
+        case Time.now - (@last_on || Time.now)
+        when 0...0.01 then return # debounce
+        when 0.01...0.3 then super :tap; @taped = true
+        when 0.3...1 then super :long_tap; @taped = true
+          #@tap_lock.synchronize do
+          #  if @tap and @tap.alive?
+          #    @tap.kill
+          #    @tap = nil
+          #    super :double_tap
+          #  else
+          #    @tap = Thread.new { sleep 0.25; super :tap }
+          #  end
+          #end
+        else super :long_tap_x2; @taped = true
+        end
+      end
+    end
+  end
+end

data/lib/domotics/core/element/dimmer.rb

@@ -0,0 +1,71 @@
+module Domotics::Core
+  class Dimmer < Element
+
+    DEFAULT_LEVEL = 0
+    MIN_LEVEL = 0
+    MAX_LEVEL = 255
+    MAX_STEPS = 128
+    STEP_DELAY = 1.0 / MAX_STEPS
+    STEP_SIZE = ((MAX_LEVEL + 1) / MAX_STEPS.to_f).round
+
+    def initialize(args = {})
+      @type = args[:type] || :dimmer
+      @fade_lock = Mutex.new
+      @fade_thread = nil
+      if args[:device_type]
+        eval_str = %(include Domotics::#{args[:device_type].capitalize}::PWMPin)
+        self.class.class_eval(eval_str, __FILE__, __LINE__)
+      end
+      super
+    end
+
+    def set_state(value = DEFAULT_LEVEL, opt = {})
+      unless opt[:kill_fader] == :no
+        @fade_lock.synchronize do
+          @fade_thread.kill if @fade_thread and @fade_thread.alive?
+        end
+      end
+      if value.is_a? Integer
+        value = MIN_LEVEL if value < MIN_LEVEL
+        value = MAX_LEVEL if value > MAX_LEVEL
+      end
+      super value
+    end
+    # Decrease brightness level (value 0-100%)
+    def dim(value = nil)
+      if value
+        set_state value * MAX_LEVEL / 100
+      else
+        set_state state - STEP_SIZE
+      end
+    end
+    # Increase brightness level (value 0-100%)
+    def bright(value = nil)
+      if value
+        set_state value * MAX_LEVEL / 100
+      else
+        set_state state + STEP_SIZE
+      end
+    end
+
+    def off
+      set_state MIN_LEVEL unless state == MIN_LEVEL
+    end
+
+    def fade_to(value = DEFAULT_LEVEL, speed_divisor = 1)
+      @fade_lock.synchronize do
+        @fade_thread.kill if @fade_thread and @fade_thread.alive?
+        @fade_thread = Thread.new do
+          op = (value - state) >= 0 ? :+ : :-
+          steps = ((value - state).abs / STEP_SIZE.to_f).round
+          steps.times do
+            set_state(state.public_send(op, STEP_SIZE), kill_fader: :no)
+            sleep speed_divisor * STEP_DELAY
+          end
+          @fade_lock.synchronize { @fade_thread = nil }
+        end
+      end
+      @fade_thread
+    end
+  end
+end

data/lib/domotics/core/element/motion_sensor.rb

@@ -0,0 +1,18 @@
+module Domotics::Core
+  class MotionSensor < Element
+    def initialize(args = {})
+      @type = args[:type] || :motion_sensor
+      if args[:device_type]
+        eval_str = %(include Domotics::#{args[:device_type].capitalize}::DigitalSensor)
+        self.class.class_eval(eval_str, __FILE__, __LINE__)
+      end
+      super
+    end
+    #def to_hls(state)
+    #  super == :on ? :move : :no_move
+    #end
+    def set_state(*args)
+      nil
+    end
+  end
+end

data/lib/domotics/core/element/reed_switch.rb

@@ -0,0 +1,18 @@
+module Domotics::Core
+  class ReedSwitch < Element
+    def initialize(args = {})
+      @type = args[:type] || :reed_switch
+      if args[:device_type]
+        eval_str = %(include Domotics::#{args[:device_type].capitalize}::NCSensor)
+        self.class.class_eval(eval_str, __FILE__, __LINE__)
+      end
+      super
+    end
+    #def to_hls(state)
+    #  super == :on ? :open : :close
+    #end
+    def set_state(*args)
+      nil
+    end
+  end
+end

data/lib/domotics/core/element/rgb_strip.rb

@@ -0,0 +1,94 @@
+module Domotics::Core
+  class RgbStrip < Element
+    def initialize(args = {})
+      @type = args[:type] || :rgb_strip
+      @strips = Hash.new
+      @crazy_lock = Mutex.new
+      @crazy_thread = nil
+      super
+      sub_args = args.dup
+      %w(r g b).each do |x|
+        sub_args[:name] = (args[:name].to_s+"_#{x}_strip").to_sym
+        sub_args[:pin] = args[x.to_sym]
+        @strips[x.to_sym] = Dimmer.new(sub_args)
+      end
+    end
+
+    def red
+      @strips[:r]
+    end
+    def green
+      @strips[:g]
+    end
+    def blue
+      @strips[:b]
+    end
+
+    def off
+      kill_crazy
+      @strips.values.each { |strip| strip.off } if on?
+      set_state :off
+    end
+
+    def color
+      @strips.values.map { |strip| strip.state }
+    end
+
+    def on?
+      color.reduce(:+) != 0
+    end
+
+    def on
+      set_color 255, 255, 255
+    end
+
+    def set_color(*args)
+      kill_crazy
+      args=args[0] if args.size == 1 and args[0].is_a? Array
+      if args.size == 3
+        @strips[:r].fade_to args[0]
+        @strips[:g].fade_to args[1]
+        @strips[:b].fade_to args[2]
+        set_state args.reduce(:+) == 0 ? :off : :on
+      end
+    end
+
+    def set_power(value=50)
+      return unless value.is_a? Integer
+      value=100 if value>100
+      value=0 if value<0
+      if state == :on
+        set_color color.map { |c| c * Dimmer::MAX_LEVEL * value / color.max / 100 }
+      else
+        set_color 3.times.map { Dimmer::MAX_LEVEL * value / 100 }
+      end
+    end
+
+    def random
+      set_color 3.times.map { rand Dimmer::MAX_LEVEL }
+    end
+
+    def crazy
+      @crazy_lock.synchronize do
+        @crazy_thread.kill if @crazy_thread
+        @crazy_thread = Thread.new do
+          loop do
+            @fade_threads = @strips.values.map { |strip| strip.fade_to(rand(Dimmer::MAX_LEVEL), 1) }
+            @fade_threads.each { |thread| thread.join }
+          end
+        end
+      end
+      set_state :on
+    end
+
+    def kill_crazy
+      @crazy_lock.synchronize do
+        if @crazy_thread
+          @crazy_thread.kill
+          @crazy_thread = nil
+        end
+      end
+    end
+
+  end
+end

data/lib/domotics/core/element/switch.rb

@@ -0,0 +1,67 @@
+module Domotics::Core
+  class Switch < Element
+    MINIMUM_LAG = 1
+    def initialize(args = {})
+      @type = args[:type] || :switch
+      @lag = nil
+      @lag_lock = Mutex.new
+      if args[:device_type]
+        eval_str = %(include Domotics::#{args[:device_type].capitalize}::DigitalPin)
+        self.class.class_eval(eval_str, __FILE__, __LINE__)
+      end
+      @initialized = false
+      super
+      @initialized = true
+    end
+    def set_state(value)
+      @initialized ? (super unless state == value) : super
+    end
+    def on(timer = nil)
+      set_state :on
+      lag(:off, timer)
+    end
+    def on?
+      state == :on
+    end
+    def delay_on(timer)
+      lag(:on, timer)
+    end
+    def off(timer = nil)
+      set_state :off
+      lag(:on, timer)
+    end
+    def off?
+      state == :off
+    end
+    def delay_off(timer)
+      lag(:off, timer)
+    end
+    def toggle(timer = nil)
+      set_state state == :off ? :on : :off
+      lag(:toggle, timer)
+    end
+    def delay_toggle(timer)
+      lag(:toggle, timer)
+    end
+
+    private
+
+    def lag(action = nil, timer = nil)
+      # Kill previous action -> out of date
+      @lag_lock.synchronize do
+        if @lag and @lag.alive?
+          @lag.kill
+          @lag = nil
+        end
+        raise ArgumentError unless (timer.is_a?(Integer) and timer >= MINIMUM_LAG)
+        # Delayed action
+        @lag = Thread.new do
+          sleep timer
+          public_send action
+        end
+      end
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/domotics/core/element_group.rb

@@ -0,0 +1,38 @@
+module Domotics::Core
+  class ElementGroup < BasicObject
+    attr_reader :name, :type, :room, :elements
+    def initialize(args = {})
+      #::Object.instance_method(:is_a?).bind(self)
+      @name = args[:name] || :undefined
+      @room = Room[args[:room]]
+      @room.register_element self, @name
+      @elements = []
+      @type = :group
+    end
+    def add_element(element)
+      @elements << element
+    end
+    def verbose_state
+      { @room.name =>
+        { :elements =>
+          { @name =>
+            { :state => nil }
+          }
+        }
+      }
+    end
+    def method_missing(method, *args, &block)
+      if @elements.map{ |el| el.respond_to? method }.reduce{ |res, n| res && n }
+        @elements.map{ |el| el.public_send method, *args, &block }.reduce{ |res, n| res && n }
+      else
+        super
+      end
+    end
+    def respond_to?(method)
+      @elements.map{ |el| el.respond_to? method }.reduce{ |res, n| res && n } || super
+    end
+    def to_s
+      "Group :#{@name} -> #{@elements}"
+    end
+  end
+end

data/lib/domotics/core/helper.rb

@@ -0,0 +1,73 @@
+# Debug - Show exception in threads
+Thread.class_eval do
+  alias_method :initialize_without_exception_show, :initialize
+  def initialize(*args, &block)
+    initialize_without_exception_show(*args) do
+      begin
+        block.call
+      rescue Exception => e
+        $logger.error { e.message }
+        $logger.debug { e.inspect }
+        raise e
+      end
+    end
+  end
+end
+
+class String
+  # Return integer (if can convert) or symbol
+  def to_isym
+    begin
+      Integer(self)
+    rescue ArgumentError
+      self.to_sym
+    end
+  end
+end
+
+module Domotics::Core
+  # Suppress no method errors
+  class BlackHole
+    def method_missing(*args)
+      self
+    end
+  end
+end
+
+module Domotics::Core
+  class TestRoom < Room
+    def initialize(args = {})
+      super
+      @events = {}
+    end
+    def event_handler(msg = {})
+      event, element = msg[:event], msg[:element]
+      if element
+        @events[element.name] ||= []
+        @events[element.name].push event => element.state
+      end
+      super
+    end
+    def last_event(element_name)
+      @events[element_name].pop if @events[element_name].respond_to? :pop
+    end
+  end
+end
+
+module Domotics::Core
+  class TestHelper
+    def self.init
+      $emul = Domotics::Arduino::BoardEmulator.new
+      Domotics::Core.add_map type: :room, class_name: "TestRoom"
+      Domotics::Core::Setup.new IO.read File.expand_path("../../../test/config.test.rb", File.dirname(__FILE__))
+    end
+  end
+end
+
+class Object 
+  def eigenclass 
+    class << self
+      self
+    end 
+  end 
+end

data/lib/domotics/core/room.rb

@@ -0,0 +1,86 @@
+module Domotics::Core
+  class Room
+    # All rooms
+    @@rooms = Hash.new
+    attr_reader :name, :type, :elements
+    def initialize(args = {})
+      @logger = args[:logger] || Logger.new(STDERR)
+      # Save self
+      @@rooms[@name = args[:name]] = self
+      @type = args[:type]
+      # Hash of elements
+      @elements = {}
+      class << @elements
+        def light
+          select { |name, element| (element.is_a? Element) and (element.type == :switch) and (name =~ /light/) }
+        end
+      end
+      # New queue thread
+      @room_queue = Queue.new
+      @queue_thread = Thread.new { loop { event_handler @room_queue.pop } }
+    end
+    # Register element
+    def register_element(element, name)
+      @elements[name] = element
+      # define accessor method (singleton)
+      instance_eval(%(def #{name}; @elements[:#{name}]; end;), __FILE__, __LINE__) unless respond_to? name
+    end
+    # Return state of all elements
+    def verbose_state
+      { @name =>
+        { :elements =>
+            @elements.inject(Hash.new) { |hash, element| hash.merge element[1].verbose_state[@name][:elements] },
+          :state => state,
+          :info => (info if respond_to? :info)
+        }
+      }
+    end
+    def state
+      nil
+    end
+    # Perform action with light
+    def light(action = :toggle)
+      case action
+      when :on, :off
+        @elements.light.values.each { |element| element.public_send(action) if element.respond_to? action }
+      when :toggle
+        light_off? ? light(:on) : light(:off)
+      end
+    end
+    def light_off?
+      @elements.light.values.reduce(true) { |res, el| res && el.off? }
+    end
+    # Method for pushing into queue
+    def notify(msg)
+      @room_queue.push(msg)
+    end
+    # Default - simple prints event
+    def event_handler(msg = {})
+      event, element = msg[:event], msg[:element]
+      @logger.info { "Event message :#{event} from #{element} with state [#{element.state}]" }
+    end
+
+    def destroy
+      @queue_thread.exit
+    end
+
+    # Return element object
+    def [](symbol = nil)
+      return @elements[symbol] if symbol
+      @elements
+    end
+    # Return requested room like element of array
+    def self.[](symbol = nil)
+      return @@rooms[symbol] if symbol
+      @@rooms
+    end
+    # Return requested room like variable
+    def method_missing(symbol, *args)
+      super unless args.size == 0
+      @@rooms[symbol] || BlackHole.new
+    end
+    def to_s
+      "Room[#{@name}](id:#{__id__})"
+    end
+  end
+end

data/lib/domotics/core/server.rb

@@ -0,0 +1,39 @@
+module Domotics::Core
+  class Server
+    def initialize(args = {})
+      @logger = $logger || Logger.new(STDERR)
+    end
+    def call(env)
+      # [object]/[action]/[params]
+      request = env['PATH_INFO'][1..-1].split('/')
+      object = request.shift
+      return invalid 'room' unless object and object = Room[object.to_sym]
+      return invalid 'element or action' unless object_action = request.shift
+      if sub_object = object[object_action.to_isym]
+        room, object = object, sub_object
+        action = request.shift
+      else
+        room = object
+        action = object_action
+      end
+      return invalid 'action' unless action and object.respond_to? action
+      begin
+        object.public_send(action, *request.map { |param| param.to_isym })
+      rescue Exception => e
+        @logger.error { e.message }
+        @logger.debug { e }
+        return invalid 'request'
+      end
+      return ok object.verbose_state.to_json
+    end
+
+    private
+
+    def invalid(param)
+      [400, {"Content-Type" => "text/html"}, ["Processing error: invalid #{param}."]]
+    end
+    def ok(param)
+      [200, {"Content-Type" => "text/html"}, [param]]
+    end
+  end
+end

data/lib/domotics/core/setup.rb

@@ -0,0 +1,74 @@
+# coding: utf-8
+module Domotics::Core
+  CLASS_MAP[:group] = :element_group
+  class Setup < BasicObject
+    @@logger = ::Logger.new(::STDERR)
+    @@logger.level = ::Logger::FATAL
+    $logger = @@logger
+    def self.logger
+      @@logger
+    end
+    def self.logger=(logger)
+      @@logger = logger
+      $logger = @@logger
+    end
+    
+    def initialize(conf)
+      @current_room = {}
+      @current_device = {}
+      @groups = []
+      instance_eval conf, __FILE__, __LINE__
+    end
+
+    def element_group(args = {})
+      raise "Element group must have room" unless @current_room.any?
+      args[:room] = @current_room[:name]
+      unless gr = Room[@current_room[:name]][args[:name]]
+        gr = ElementGroup.new args
+        @groups[-1].add_element gr if @groups[-1]
+      end
+      @groups.push(gr)
+      yield if ::Kernel.block_given?
+      @groups.pop
+    end
+
+    def room(klass, args = {})
+      @current_room[:name] = args[:name]
+      @current_room[:type] = args[:type]
+      klass.new(args) unless Room[args[:name]]
+      yield if ::Kernel.block_given?
+      @current_room.clear
+    end
+
+    def device(klass, args = {})
+      @current_device[:name] = args[:name]
+      @current_device[:type] = args[:type]
+      klass.new(args) unless Device[args[:name]]
+      yield if ::Kernel.block_given?
+      @current_device.clear
+    end
+
+    def element(klass, args = {})
+      raise "Element must have room" unless @current_room.any?
+      args[:room] = Room[@current_room[:name]]
+      args[:room_type] = @current_room[:type]
+      args[:device] = Device[@current_device[:name]]
+      args[:device_type] = @current_device[:type]
+      klass = klass.dup if args[:device_type]
+      el = klass.new(args) unless Room[@current_room[:name]][args[:name]]
+      @groups[-1].add_element el if @groups[-1]
+    end
+
+    def method_missing(symbol, *args, &block)
+      if CLASS_MAP[symbol] and name = args.shift
+        args_hash = args.shift || {}
+        args_hash[:name] = name
+        args_hash[:type] = symbol if CLASS_MAP[symbol][0] != :element
+        args_hash[:logger] = @@logger
+        __send__(*CLASS_MAP[symbol], args_hash, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/domotics/core/version.rb

@@ -1,5 +1,5 @@
 module Domotics
   module Core
-    VERSION = "0.0.1"
+    VERSION = "0.1.0"
   end
 end

data/test/config.test.rb

@@ -0,0 +1,16 @@
+test_room :test do
+  button :button_no_dev
+  dimmer :dimmer_no_dev
+  motion_sensor :ms_no_dev
+  reed_switch :rs_no_dev
+  rgb_strip :rgb_no_dev
+  switch :light_no_dev
+  arduino :nano, board: :nano, port: $emul.port do
+    button :button, pin: 6
+    dimmer :dimmer, pin: 3
+    motion_sensor :ms, pin: 7
+    reed_switch :rs, pin: 8
+    rgb_strip :rgb, r: 9, g: 10, b: 11
+    switch :light_1, pin: 13
+  end
+end

data/test/test_devices.rb

@@ -0,0 +1,9 @@
+ENV['RACK_ENV'] = 'test'
+
+require "test/unit"
+require "domotics/core"
+
+Domotics::Core::TestHelper.init
+
+class DomoticsDevicesTestCase < Test::Unit::TestCase
+end

data/test/test_elements.rb

@@ -0,0 +1,63 @@
+ENV['RACK_ENV'] = 'test'
+
+require "test/unit"
+require "domotics/core"
+
+class DomoticsElementsTestCase < Test::Unit::TestCase
+  def test_dimmer
+    dimmer = Domotics::Core::Room[:test].dimmer
+    # Should turn on max and convert state to int
+    dimmer.set_state :on
+    assert_equal 255, dimmer.state
+    # Should turn off and convert state to int
+    dimmer.set_state :off
+    assert_equal 0, dimmer.state
+    # Dim
+    [0,3,24,127,237,255].each do |val|
+      dimmer.set_state val
+      assert_equal val, dimmer.state
+    end
+    # Off
+    dimmer.off
+    assert_equal 0, dimmer.state
+    # Fade to
+    dimmer.fade_to 255
+    sleep 1.6
+    assert_equal 255, dimmer.state
+    dimmer.fade_to 127
+    sleep 0.8
+    assert_equal 127, dimmer.state
+    dimmer.fade_to 0
+    sleep 0.8
+    assert_equal 0, dimmer.state
+  end
+
+  def test_rgb_strip
+    rgb = Domotics::Core::Room[:test].rgb
+    rgb.on
+    sleep 1.6
+    assert_equal 255, rgb.red.state
+    rgb.off
+    assert_equal 0, rgb.red.state
+    assert_equal :dimmer, rgb.red.type
+    assert_equal :dimmer, rgb.green.type
+    assert_equal :dimmer, rgb.blue.type
+  end
+
+  def test_button
+    room = Domotics::Core::Room[:test]
+    btn = room.button
+
+    $emul.set_internal_state 6, 1
+    $emul.toggle_pin 6
+    sleep 0.1
+    $emul.toggle_pin 6
+    sleep 0.05
+    assert_equal room.last_event(btn.name), :state_changed => :tap
+    $emul.toggle_pin 6
+    sleep 0.6
+    $emul.toggle_pin 6
+    sleep 0.01
+    assert_equal room.last_event(btn.name), :state_changed => :long_tap
+  end
+end

data/test/test_rooms.rb

@@ -0,0 +1,17 @@
+ENV['RACK_ENV'] = 'test'
+
+require "test/unit"
+require "domotics/core"
+
+class DomoticsRoomsTestCase < Test::Unit::TestCase
+  def test_room
+    tr = Domotics::Core::Room.new name: :tr
+    assert_raise NoMethodError do
+      tr.instance_eval { no_method :arg1 }
+    end
+    assert_nothing_raised do
+      tr.instance_eval { nothing.off }
+      tr.instance_eval { nothing.light :off }
+    end
+  end
+end

data/test/test_server.rb

@@ -0,0 +1,57 @@
+#ENV['RACK_ENV'] = 'test'
+
+require "domotics/core"
+require 'test/unit'
+require 'rack/test'
+
+class DomoticsTest < Test::Unit::TestCase
+  include Rack::Test::Methods
+
+  def app
+    Domotics::Core::Server.new
+  end
+
+  def test_valid_object
+    get '/to_s'
+    assert last_response.bad_request?
+    get '/test/to_s'
+    assert last_response.ok?
+    get '/test/light_1/to_s'
+    assert last_response.ok?
+    get '/invalid_object/to_s'
+    assert last_response.bad_request?
+    get '/test/invalid_object/to_s'
+    assert last_response.bad_request?
+  end
+
+  def test_query_action
+    get '/test/light_1/state'
+    assert last_response.ok?
+    get '/test/light_1/abracadabra'
+    assert last_response.bad_request?
+    get '/test/light_1/state/abracadabra'
+    assert last_response.bad_request?
+  end
+
+  def test_switch_element
+    get '/test/light_1/on'
+    assert last_response.ok?
+    get '/test/light_1/delay_off/1'
+    assert last_response.ok?
+    sleep 1.2
+    get '/test/light_1/delay_on/1'
+    assert last_response.ok?
+    sleep 1.2
+    3.times do
+      sleep 1
+      get '/test/light_1/toggle'
+      assert last_response.ok?
+    end
+    get '/test/light_1/delay_toggle/1'
+    assert last_response.ok?
+    sleep 2
+    get '/test/light_1/off'
+    assert last_response.ok?
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: domotics-core
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - goredar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-28 00:00:00.000000000 Z
+date: 2014-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,7 +52,29 @@ files:
 - Rakefile
 - domotics-core.gemspec
 - lib/domotics/core.rb
+- lib/domotics/core/data/data_hash.rb
+- lib/domotics/core/data/data_mongo.rb
+- lib/domotics/core/data/data_redis.rb
+- lib/domotics/core/device.rb
+- lib/domotics/core/device/arduino_board.rb
+- lib/domotics/core/element.rb
+- lib/domotics/core/element/button.rb
+- lib/domotics/core/element/dimmer.rb
+- lib/domotics/core/element/motion_sensor.rb
+- lib/domotics/core/element/reed_switch.rb
+- lib/domotics/core/element/rgb_strip.rb
+- lib/domotics/core/element/switch.rb
+- lib/domotics/core/element_group.rb
+- lib/domotics/core/helper.rb
+- lib/domotics/core/room.rb
+- lib/domotics/core/server.rb
+- lib/domotics/core/setup.rb
 - lib/domotics/core/version.rb
+- test/config.test.rb
+- test/test_devices.rb
+- test/test_elements.rb
+- test/test_rooms.rb
+- test/test_server.rb
 homepage: https://goredar.it
 licenses:
 - MIT
@@ -73,8 +95,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Home automation system.
-test_files: []
+test_files:
+- test/config.test.rb
+- test/test_devices.rb
+- test/test_elements.rb
+- test/test_rooms.rb
+- test/test_server.rb