qml 0.0.7 → 1.0.0

data/lib/qml/plugins.rb

@@ -1,25 +1,11 @@
-require 'qml/plugin_loader'
-require 'qml/root_path'
 require 'pathname'
 
 module QML
+  # @api private
   module Plugins
-
-    PATH = ROOT_PATH + 'ext/qml/plugins'
-
     class << self
-      def core
-        @core ||= load('core')
-      end
-
-      def test_util
-        @test_util ||= load('testutil')
-      end
-
-      private
-
-      def load(name)
-        QML::PluginLoader.new(PATH + name, "rubyqml-#{name}").instance
+      def rubyqml
+        @plugin ||= QML::PluginLoader.new(ROOT_PATH + "ext/qml/rubyqml-plugin", "rubyqml-plugin").instance
       end
     end
   end

data/lib/qml/proc_access.rb

@@ -0,0 +1,28 @@
+module QML
+  class ProcAccess
+    include Access
+    register_to_qml under: 'RubyQml', version: QML::VERSION
+
+    def call(args)
+      @proc.call(*args)
+    end
+
+    # @return [QML::JSFunction]
+    def self.wrap_proc(prc)
+      @bind_call ||= QML.engine.evaluate <<-JS
+        (function (access) { return access.call.bind(access); })
+      JS
+
+      @component ||= QML::Component.new(data: <<-QML)
+        import RubyQml 1.0
+        ProcAccess {}
+      QML
+
+      access = @component.create
+      access.unwrap.instance_eval do
+        @proc = prc
+      end
+      @bind_call.call(access)
+    end
+  end
+end

data/lib/qml/qt.rb

@@ -1,6 +1,24 @@
-require 'qml/qt_classes'
 
 module QML
-  # @!parse class Qt < QtObjectBase; end
-  class Qt; end
+  module_function
+
+  # @example
+  #   def set_app_name
+  #     QML.qt.application.name = 'appname'
+  #   end
+  # @return [JSObject] QML Qt namespace object
+  # @see http://doc.qt.io/qt-5/qml-qtqml-qt.html
+  def qt
+    @qt ||= begin
+      component = QML::Component.new data: <<-QML
+        import QtQuick 2.0
+        QtObject {
+          function getQt() {
+            return Qt;
+          }
+        }
+      QML
+      component.create.getQt
+    end
+  end
 end

data/lib/qml/reactive.rb

@@ -1,8 +1,147 @@
-require 'qml/reactive/signal'
-require 'qml/reactive/signals/map_signal'
-require 'qml/reactive/signals/select_signal'
-require 'qml/reactive/signals/merge_signal'
-require 'qml/reactive/signal_spy'
-require 'qml/reactive/property'
-require 'qml/reactive/object'
-require 'qml/reactive/error'
+module QML
+
+  module Reactive
+    # @!parse extend ClassMethods
+
+    # @api private
+    class PropertyInfo
+      attr_accessor :initializer
+    end
+
+    # @api private
+    class SignalInfo
+      attr_accessor :params
+      attr_accessor :listeners
+
+      def initialize
+        @listeners = []
+      end
+    end
+
+    def initialize(*args, &block)
+
+      self.class.property_infos.each do |name, info|
+        if info.initializer
+          self.__send__ :"#{name}=", instance_eval(&info.initializer)
+        end
+      end
+
+      self.class.signal_infos.each do |name, info|
+        __send__(name).connect do |*args|
+          info.listeners.each do |listener|
+            instance_exec(*args, &listener)
+          end
+        end
+      end
+
+      super
+    end
+
+    def self.included(derived)
+      derived.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+
+      # @api public
+      # Defines a signal.
+      # @example
+      #  class Button
+      #    include QML::Reactive::Object
+      #    signal :pressed, [:pos]
+      #    ...
+      #  end
+      def signal(name, params = [])
+        name = name.to_sym
+        signal_infos(false)[name] = SignalInfo.new.tap do |info|
+          info.params = params.map(&:to_sym)
+        end
+
+        class_eval <<-EOS, __FILE__, __LINE__ + 1
+          def #{name}
+            @_signal_#{name} ||= begin
+              args = self.class.signal_infos[:#{name}].params
+              Signal.new(args)
+            end
+          end
+        EOS
+
+        name
+      end
+
+      private :signal
+
+      def signals(include_super = true)
+        signal_infos(include_super).keys
+      end
+
+      def signal_infos(include_super = true)
+        if include_super && superclass.include?(Access)
+          superclass.signal_infos.merge(signal_infos(false))
+        else
+          @signal_infos ||= {}
+        end
+      end
+
+      # Defines a property.
+      # @example
+      #   class Foo
+      #     include QML::Access
+      #     property(:name) { 'hogehoge' }
+      #     ...
+      #   end
+      def property(name, &block)
+        name = name.to_sym
+        signal(:"#{name}_changed", [:"new_#{name}"])
+
+        property_infos(false)[name] = PropertyInfo.new.tap do |info|
+          info.initializer = block
+        end
+
+        class_eval <<-EOS, __FILE__, __LINE__ + 1
+          attr_reader :#{name}
+          def #{name}=(new_value)
+            new_value = new_value
+            if @#{name} != new_value
+              @#{name} = new_value
+              #{name}_changed.emit(new_value)
+            end
+          end
+        EOS
+
+        name
+      end
+
+      private :property
+
+      def properties(include_super = true)
+        property_infos(include_super).keys
+      end
+
+      def property_infos(include_super = true)
+        if include_super && superclass.include?(Access)
+          superclass.property_infos.merge(property_infos(false))
+        else
+          @property_infos ||= {}
+        end
+      end
+
+      def on(signal, &block)
+        info = signal_infos(false)[signal.to_sym] or fail AccessError, "no signal `#{signal}` found"
+        info.listeners << block
+        block
+      end
+
+      def on_changed(property, &block)
+        on(:"#{property}_changed", &block)
+      end
+
+      private :on, :on_changed
+
+    end
+
+  end
+
+end

data/lib/qml/signal.rb

@@ -0,0 +1,67 @@
+module QML
+
+  class Signal
+
+    class Connection
+      def initialize(signal, listener)
+        @signal = signal
+        @listener = listener
+      end
+
+      # Disconnects the connection.
+      def disconnect
+        @signal.disconnect(@listener)
+      end
+    end
+
+    attr_reader :arity
+
+    # Initializes the Signal.
+    # @param [Array<#to_sym>, nil] params the parameter names (the signal will be variadic if nil).
+    def initialize(params)
+      @listeners = []
+      @params = params.map(&:to_sym)
+      @arity = params.size
+    end
+
+    # Calls every connected procedure with given arguments.
+    # Raises an ArgumentError when the arity is wrong.
+    # @param args the arguments.
+    def emit(*args)
+      if args.size != @arity
+        fail ::ArgumentError ,"wrong number of arguments for signal (#{args.size} for #{@arity})"
+      end
+      @listeners.each do |listener|
+        listener.call(*args)
+      end
+    end
+
+    # Returns the format of the parameters in the same format as Proc#parameters.
+    # @return [Array<Array<Symbol>>]
+    def parameters
+      @params ? @params.map { |arg| [:req, arg] } : [[:rest, :args]]
+    end
+
+    # Returns the number of connections.
+    # @return [Integer]
+    def connection_count
+      @listeners.size
+    end
+
+    # Connects a procedure.
+    # @yield called when #emit is called.
+    # @return [QML::Signal::Connection]
+    def connect(&listener)
+      @listeners << listener
+      Connection.new(self, listener)
+    end
+
+    # Disconnects a procedure.
+    # @param listener
+    # @return [self]
+    def disconnect(listener)
+      @listeners.delete(listener)
+      self
+    end
+  end
+end

data/lib/qml/version.rb

@@ -1,3 +1,3 @@
 module QML
-  VERSION = '0.0.7'
+  VERSION = '1.0.0'
 end

data/qml.gemspec

@@ -13,7 +13,14 @@ Gem::Specification.new do |spec|
   spec.homepage      = "http://seanchas116.github.io/ruby-qml/"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0")
+  qmlbind_dir = "ext/qml/lib/libqmlbind"
+  qmlbind_files = Dir.chdir(qmlbind_dir) do
+    `git ls-files -z`
+      .split("\x0")
+      .map { |file| "#{qmlbind_dir}/#{file}" }
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0") + qmlbind_files
   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"]
@@ -25,7 +32,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.3"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency 'pry'
-  spec.add_development_dependency 'celluloid'
   spec.add_development_dependency 'twitter', '~> 5.11'
   spec.add_development_dependency 'sequel', '~> 4.12'
   spec.add_development_dependency 'sqlite3', '~> 1.3'

data/spec/qml/access_spec.rb

@@ -1,93 +1,69 @@
 require 'spec_helper'
 
 describe QML::Access do
-  class Foo
-    include QML::Access
 
-    property :text
-    signal :some_signal, [:arg]
-
-    def some_method(a, b)
-      a + b
-    end
-
-    def variadic_method(*args)
-    end
-  end
-
-  class Bar < Foo
-    def some_method(a, b)
-      'overridden'
-    end
-
-    def bar_method
-      'bar'
-    end
-  end
-
-  let(:context) { QML::Context.new }
-  let(:component) { QML::Component.new context: context, data: data }
+  let(:component) { QML::Component.new data: data }
   let(:root) { component.create }
 
   describe '.register_to_qml' do
 
     context 'when namespace, version, name are given' do
 
-      class Hoge
-        include QML::Access
-
-        register_to_qml under: 'HogeNS', version: '1.2', name: 'Hoge'
-
-        property :text
-
-        def some_method(a, b)
-          a + b
-        end
-      end
-
       let(:data) do
         <<-EOS
           import QtQuick 2.2
-          import HogeNS 1.2
+          import AccessExampleNS 1.2
           Item {
             id: root
-            property var bound: hoge.text + hoge.text
-            Hoge { id: hoge }
+            property var bound: example.text + example.text
+            function getExample() {
+              return example;
+            }
+            function callSomeMethod() {
+              return example.some_method(100, 200);
+            }
+            AccessExample {
+              id: example
+              property var signalArg
+              onSome_signal: {
+                signalArg = arg;
+              }
+            }
           }
         EOS
       end
+      let(:example) { root.getExample }
+
       it 'registers the class as a QML type' do
         expect { component.create }.not_to raise_error
       end
-      describe 'Hoge#some_method' do
+      describe 'AccessExamle#some_method' do
         it 'returns value' do
-          expect(root.qml_eval('hoge.some_method(100, 200)')).to eq 300
+          expect(root.callSomeMethod()).to eq 300
         end
       end
-      describe 'Hoge text property' do
+      describe 'AccessExamle text property' do
         it 'can be used to property binding' do
-          root.qml_eval('hoge').text = "foo"
-          expect(root.qml_eval('root').bound).to eq 'foofoo'
-          root.qml_eval('hoge').text = "bar"
-          expect(root.qml_eval('root').bound).to eq 'barbar'
+          example.text = "foo"
+          expect(root.bound).to eq 'foofoo'
+          example.text = "bar"
+          expect(root.bound).to eq 'barbar'
+        end
+      end
+      describe 'AccessExamle some_signal signal' do
+        it 'can be connected' do
+          example.unwrap.some_signal.emit('foo')
+          expect(example.signalArg).to eq 'foo'
         end
       end
     end
 
     context 'when arguments are omitted' do
 
-      module HogeModule
-        VERSION = '0.1.0'
-        class Hoge
-          include QML::Access
-          register_to_qml
-        end
-      end
-
       let(:data) do
         <<-EOS
-          import HogeModule 0.1
-          Hoge {}
+          import AccessExampleModule 0.1
+          AccessExample {}
         EOS
       end
 
@@ -96,67 +72,4 @@ describe QML::Access do
       end
     end
   end
-
-  context 'when used in context' do
-
-    let(:data) do
-      <<-EOS
-        import QtQuick 2.2
-        Item {
-          id: root
-          property string text: foo.text + foo.text
-          Connections {
-            id: connections
-            target: foo
-            property var args
-            onSome_signal: {
-              args = [arg]
-            }
-          }
-        }
-      EOS
-    end
-    let(:foo) { Foo.new }
-    let(:bar) { Bar.new }
-
-    before do
-      context[:foo] = foo
-      context[:bar] = bar
-      root
-    end
-
-    describe 'Foo#some_method' do
-      it 'returns value' do
-        expect(root.qml_eval('foo.some_method(100, 200)')).to eq 300
-      end
-    end
-    describe 'Bar#some_method' do
-      it 'returns value' do
-        expect(root.qml_eval('bar.some_method(100, 200)')).to eq 'overridden'
-      end
-    end
-    describe 'Foo#variadic_method' do
-      it 'will not be exported' do
-        expect { root.qml_eval('foo.variadic_method()') }.to raise_error(QML::QMLError)
-      end
-    end
-    describe 'Foo text property' do
-      it 'can get and set value' do
-        root.qml_eval('foo').text = 'test'
-        expect(root.qml_eval('foo').text).to eq 'test'
-      end
-      it 'can be used for property binding' do
-        foo.text = 'hoge'
-        expect(root.qml_eval('root.text')).to eq 'hogehoge'
-        foo.text = 'piyo'
-        expect(root.qml_eval('root.text')).to eq 'piyopiyo'
-      end
-    end
-    describe 'Foo some_signal signal' do
-      it 'can be connected' do
-        foo.some_signal.emit('foo')
-        expect(root.qml_eval('connections.args')).to eq ['foo']
-      end
-    end
-  end
 end