windows 0.0.1

data/lib/windows/units/recognizer.rb

@@ -0,0 +1,68 @@
+module Windows
+  module Units
+    module Recognizer
+      module Formats
+        class Base < Struct.new(:el)
+          attr_accessor :unit
+
+          def match
+            raise "you should implement your match"
+          end
+
+          def format
+            self.class.to_s.split("::").last.downcase.to_sym
+          end
+
+          def return_match(matcher, data,&block)
+            data = if data
+              matcher.instance_eval &block
+              matcher
+            else
+              nil
+            end
+          end
+        end
+
+        class Pixel < Base
+          # match 50, 50.5, 50.02
+          def match
+            data = el.kind_of?(Numeric)
+            item = return_match(self, data) { @unit = el }
+          end
+        end
+
+        class Percent < Base
+          # match 50px, 50PX, 50.5px, 50.1PX
+          def match
+            return false unless el.respond_to?(:match)
+
+            data  = el.match(/(^[\d.]+)(%)/i)
+            return_match(self, data) { @unit = Float(data[1]) }
+          end
+        end
+
+        RECOGNIZERS = [Pixel, Percent]
+      end
+
+      class Finder < Struct.new(:el)
+        include Formats
+
+        def run
+          item = RECOGNIZERS.map do |klass|
+            recognizer = klass.new(el)
+            recognizer.match
+          end.compact.first
+
+          raise "I don't know how to recognize this unit #{el}" unless item
+          item
+        end
+      end
+
+      def recognize_unit(el)
+        @recognize_unit_engine ||= Finder.new
+        @recognize_unit_engine.el = el
+        @recognize_unit_engine.run
+      end
+    end
+  end
+end

data/lib/windows/units/unit_converter.rb

@@ -0,0 +1,73 @@
+require 'windows/units/converter'
+require 'windows/units/recognizer'
+require 'windows/structures'
+
+module Windows
+  module Units
+    class UnitConverter
+      include Units::Converter
+      include Units::Recognizer
+      include Structures
+
+      NAMED_GEOMETRY = {
+        left:         [0,  0,  '50%',  '100%'],
+        right:        ['50%', 0,  '50%',  '100%'],
+        bottom:       [0,  '50%', '100%', '50%'],
+        top:          [0,  0,  '100%', '50%'], 
+        max:          [0,  0,  '100%', '100%'],
+        bottom_right: ['50%', '50%', '50%', '50%'],
+        bottom_left:  [0, '50%', '50%', '50%'],
+        top_right:    ['50%', 0, '50%', '50%'],
+        top_left:     [0, 0, '50%', '50%']
+      }
+
+      def initialize(desktop, *args)
+        @width    = desktop.width
+        @height   = desktop.height
+        @geometry = create_geometry(args)
+        @x_offset = desktop.x_offset
+        @y_offset = desktop.y_offset
+        @x_axis   = [@geometry.x, @geometry.w]
+        @y_axis   = [@geometry.y, @geometry.h]
+      end
+
+      def convert
+        x, w = @x_axis.map do |el|
+          item = recognize_unit(el)
+          converter(item.unit).to(item.format, base: @width)
+        end
+
+        y, h = @y_axis.map do |el|
+          item = recognize_unit(el)
+          converter(item.unit).to(item.format, base: @height)
+        end
+
+        x = x + @x_offset
+        y = y + @y_offset
+
+        [x, y, w, h]
+      end
+
+      private
+
+      def create_geometry(args)
+        return Geometry.new(*args) if args.count > 1
+
+        if args[0].respond_to?(:to_sym) && geometry_exist?(args[0])
+          args = find_geometry(args[0].to_sym)
+          return Geometry.new(*args)
+        else
+          raise "Geometry with name #{args[0]} not exist. You can use #{NAMED_GEOMETRY.keys}"
+        end
+      end
+
+      def find_geometry(name)
+        NAMED_GEOMETRY[name.to_sym]
+      end
+
+      def geometry_exist?(name)
+        NAMED_GEOMETRY.keys.include?(name.to_sym)
+      end
+    end
+  end
+end

data/lib/windows/version.rb

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

data/samples/moving_windows.rb

@@ -0,0 +1,22 @@
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__),'../lib'))
+require 'windows'
+
+terminal1 = Windows::Window.new('x-www-browser')
+terminal2 = Windows::Window.new('x-www-browser')
+terminal3 = Windows::Window.new('x-www-browser')
+windows   = [terminal1, terminal2, terminal3]
+
+# first create all windows
+windows.each(&:create)
+
+# move with percentage values
+terminal1.move '50%', '50%', '50%', '50%'
+
+# move with special named argument
+terminal2.move :top_right
+
+# move with pixels
+terminal3.move 0, 0, 300, 300
+
+sleep 5
+windows.each(&:close)

data/samples/project.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift lib = File.expand_path(File.join(File.dirname(__FILE__),'../lib'))
+require 'windows'
+
+p = Windows::Project.new(:default,lib)
+
+p.open_window('x-www-browser').move(:right)
+p.open_window('x-terminal-emulator').move(:bottom)
+
+sleep 5
+p.close

data/spec/core_ext/numeric.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'windows/core_ext/numeric'
+
+describe Numeric do
+  context "#percent" do
+    it 'return correct value' do
+      1000.percent(10).should == 100
+    end
+
+    it 'floor result' do
+      999.percent(31.53).should == 314
+    end
+  end
+end

data/spec/engines/wmctrl_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'windows/engines/wmctrl'
+require 'time'
+
+describe WMCtrl do
+  let(:fake_window_id) { 1234 }
+  let(:window)         { Windows::Structures::Window.new(fake_window_id) }
+  let(:time)           { Time.parse("Sep 13 2011") }
+  let(:command)        { 'any_command' }
+
+  before :each do
+    create_windows
+    create_desktops
+  end
+
+  context "spawn_window" do
+    it 'should raise exception when command not exist' do
+      Process.stub(:spawn).and_raise(Errno::ENOENT)
+      expect { subject.spawn_window(command) }.to raise_error "Failed to create window with command: #{command}. Maybe a typo?"
+    end
+  end
+
+  it "#desktops" do
+    list = subject.desktops
+    desktops.zip(list).each do |desktop, desktop_window|
+      desktop[:id].should       == desktop_window.id   
+      desktop[:workarea].should == desktop_window.geometry         
+    end
+
+    list.should be_instance_of(Windows::Structures::Collection)
+  end
+
+  it "#find_desktops" do
+    desktop = subject.find_desktop(1)
+    desktop.id.should == 1
+    desktop.should be_instance_of(Windows::Structures::Desktop)
+  end
+
+  context "#windows" do
+    it 'return windows' do
+      list = subject.windows
+
+      windows(:sorted).zip(list).each do |stub, window|
+        desktop = subject.find_desktop(stub[:desktop])
+
+        stub[:id].should          == window.id
+        stub[:title].should       == window.title
+        stub[:desktop].should     == desktop.id
+        stub[:geometry][0].should == window.x
+        stub[:geometry][1].should == window.y
+        stub[:geometry][2].should == window.width
+        stub[:geometry][3].should == window.height
+      end
+
+      list.should be_instance_of(Windows::Structures::Collection)
+    end
+
+    it 'return sorted by :id' do
+      expected_ids = windows(:sorted).map {|w| w[:id]}
+
+      subject.windows.ids.should == expected_ids
+    end
+  end
+
+  context "#find_windows" do
+    it 'should find window by id' do
+      subject.find_window(2).id.should == 2
+    end
+
+    it 'should return Window' do
+      subject.find_window(2).should be_instance_of Windows::Structures::Window
+    end
+  end
+
+  it '#active_window' do
+    subject.active_window.active.should be_true
+  end
+
+  private
+
+  def desktops
+    unless @desktops
+      klass = Windows::Structures::Desktop
+      @desktops = []
+      @desktops.push({id: 1, workarea: [0, 0, 800, 600]})
+      @desktops.push({id: 2, workarea: [0, 0, 1200, 1000]})
+    end
+    @desktops
+  end
+
+  def windows(sorted = false)
+    unless @windows
+    klass = Windows::Structures::Window
+    @windows = []
+    @windows.push({id: 1, title: 'bash', desktop: 1, geometry: [0,0,100,200]})
+    @windows.push({id: 3, title: 'torr', desktop: 2, geometry: [100,100,400,800]})
+    @windows.push({id: 2, title: 'list', desktop: 1, geometry: [50,50,200,400], active: true})
+    end
+    sorted ? @windows.sort_by{|w| w[:id]} : @windows 
+  end
+
+  def create_windows
+    subject.stub(:list_windows).and_return(windows)
+  end
+
+  def create_desktops
+    subject.stub(:list_desktops).and_return(desktops)
+  end
+
+end

data/spec/engines/xwindow_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+require 'time'
+require 'windows/engines/xwindow'
+require 'windows/structures/window'
+require 'windows/structures/desktop'
+
+module Windows
+  module Engines
+    class WMCtrl
+    end
+  end
+end
+
+class DummyEngine
+  def action(*args)
+  end
+
+  def spawn_window(command)
+    fake_window
+  end
+
+  def find_window(id)
+    fake_window
+  end
+
+  def fake_window
+    Windows::Structures::Window.new(1234, 'fake window', fake_desktop)
+  end
+
+  private
+
+  def fake_desktop
+    Windows::Structures::Desktop.new(9876, [0,0,800,600])
+  end
+end
+class DummyWindow < Struct.new(:id, :title);end
+class DummyDesktop < Struct.new(:x_offset, :y_offset, :width, :height);end
+
+describe Windows::Engines::XWindow do
+  subject { Windows::Engines::XWindow.new(command, options, engine)}
+  let(:engine)  { DummyEngine.new }
+  let(:command) { 'ls' }
+  let(:time)    { Time.parse("Sep 13 2011")}
+  let(:options) { Hash.new }
+  let(:window)  { engine.fake_window }
+  let(:id)      { window.id }
+
+  it { should delegate(:title).to(:window) }
+  it { should delegate(:desktop).to(:window) }
+  it { should delegate(:x).to(:window) }
+  it { should delegate(:y).to(:window) }
+  it { should delegate(:width).to(:window) }
+  it { should delegate(:height).to(:window) } 
+  it { should respond_to :command= }
+
+  it '#move' do
+    args = [100, 200, 500, 400]
+
+    subject.should_receive(:undock).ordered
+    engine.should_receive(:action).with(id, :move_resize, 0, *args).ordered
+    subject.move(*args)
+  end
+
+  context 'close' do
+    it 'should delegate to engine' do
+      engine.should_receive(:action).with(id, :close)
+      subject.close
+    end
+
+    it 'should :id, :created_at set to false' do
+      subject.create
+      subject.close
+      subject.id.should == false
+      subject.created_at.should == false
+    end
+  end
+
+  it '#focus' do
+    engine.should_receive(:action).with(id, :activate)
+    subject.focus  
+  end
+
+  it '#undock' do
+    args = ["remove", "maximized_vert", "maximized_horz"]
+
+    engine.should_receive(:action).with(id, :change_state, *args)
+    subject.undock
+  end
+
+  context "#create" do
+    before(:each) do
+      Time.stub!(:now).and_return(time)
+    end
+
+    it 'should assign id' do
+      subject.create
+      subject.id.should == engine.fake_window.id 
+    end
+
+    it 'should assign created_at' do
+      subject.create
+      subject.created_at.should == time
+    end
+
+    it 'should return false when window is already created' do
+      subject.create
+      subject.create.should be_false
+    end
+
+    it 'should not spawn new window when it exist' do
+      engine.should_receive(:find_window).with(command).and_return(window)
+      engine.should_not_receive(:spawn_window).with(command)
+      subject.create
+    end
+  end
+
+  context '#window' do
+    context "when window is not created" do
+      it 'should create window' do
+        subject.should_receive(:create)
+        subject.window
+      end
+    end
+
+    context "when window is created" do
+      before do
+        subject.create
+      end
+
+      it 'should delegate to engine' do
+        engine.should_receive(:find_window).with(id)
+        subject.window
+      end
+    end
+  end
+
+  it '#on_top' do
+    engine.should_receive(:action).with(id, :change_state, "add", "above")
+    subject.on_top
+  end
+
+  it '#not_on_top' do
+    engine.should_receive(:action).with(id, :change_state, "remove", "above")
+    subject.not_on_top
+  end
+
+  context "#action" do
+    it 'should delegate to engine' do
+      args = [0, 0, 0, 100, 200]
+
+      engine.should_receive(:action).with(id, *args)
+      subject.action(*args)
+    end
+
+    it 'should return self' do
+      subject.action.should == subject
+    end
+  end
+
+  it '#maximize' do
+    engine.should_receive(:action).with(id, :change_state, "add", "maximized_vert", "maximized_horz")
+    subject.maximize
+  end
+ 
+  context "initialize" do
+    it "should use WMCtrl as default engine" do
+      object = subject.class.new(command, options, nil)
+      object.engine.should be_instance_of(Windows::Engines::WMCtrl)
+    end
+  end
+end