such 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 034ecc706d9a4c43a76d423f2c923a6a0d83f1e6
+  data.tar.gz: 046e83830b08e094b1c3bf5e6105eebf1e15337e
+SHA512:
+  metadata.gz: cb4627c8552d8b29a0f688428daac053bfcfab9aec5a35c463ea10600344696cce34e2f9860c7d7dd0a0a4b01a9aa1d71ee43ab2f5ec5db262b8f355bb14af58
+  data.tar.gz: e6456431c3c453541111db1afd0311ddfd1331c61db3557594f8a4f3ae7bc97d351794138f98a4d51780b53bec5ca35bf5824fc0b4a6e17bfebb0cdb0ece5d8e

data/README.rdoc

@@ -0,0 +1,101 @@
+= Such
+
+== DESCRIPTION:
+
+Wraps Ruby's Gtk widgets with an alternate constructor
+which factors out the configuration and assembly procedures into metadata.
+
+And the _Such_ module can be used to wrap any class with the alternate constructor,
+although currently only _Gtk3_ widgets is supported.
+
+== SYNOPSIS:
+
+   require 'gtk3'
+   require 'such'
+   include Such; Things.gtk_widget
+
+   Thing.configure window: {
+                     set_title: 'Synopsis Example',
+                     set_window_position: :center },
+                   BUTTON: [label: 'Button!'],
+                   button: {set_size_request: [100,50], into:[:add]}
+
+   window = Window.new(:window, 'destroy'){Gtk.main_quit}
+     Button.new(window, :button!){puts 'Button pressed!'}
+   window.show_all
+
+   Gtk.main
+
+== MORE:
+
+Arrays are passed to constructer's super,
+Hashes are method=>arguments pairs, and Strings are signals.
+Other objects are assumed to be containers:
+
+   Such::Button.new(window, [label: 'Hello!'], {set_size_request:[100,50]}, 'clicked' ){puts 'OK'}
+
+   # Is equivalent to
+
+   button = Gtk::Button.new(label:'Hello!')
+   window.add button
+   button.set_size_request 100, 50
+   button.signal_connect('clicked'){puts 'OK'}
+
+To set the packing method to say, :pack_start, set the :into method as follows:
+
+   {into: [:pack_start, expand:false, fill:false, padding:0]}
+   # The effect in the contructor will be as if the following was run:
+   #    container.pack_start(self, expand:false, fill:false, padding:0)
+
+One can configure Symbol keys to represent metadata about a widget:
+
+   Thing.configure(
+     KEY: [ arg1, arg2, arg3 ], # an array for super(arg1, arg2, arg3)
+     key: {                     # a hash for like self.method(args)
+       meth1:args1,
+       meth2:[args2a, args2b],
+       meth3:[a,b,c,d]
+     },
+     key!: [[arg1, arg2], {meth1:args1, meth2:args2}, 'signal1', 'signal2'] # the splatter bang!
+   )
+
+The examples in this repository are reworks of the examples given in
+ZetCode.com[http://zetcode.com/gui/rubygtk/].
+
+=== Features:
+
+* :key! content *splat
+* Undefined :key! expanded to :KEY, :key
+* Missing signal assumed to be 'clicked'
+* Heuristics on when one wants to iterate a method over the arguments given
+* Packing method defaults (ultimately) to :add
+* Way to change default packing behaviour
+
+== INSTALL:
+
+  $ sudo gem install such
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2014 
+
+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/lib/such/such.rb

@@ -0,0 +1,9 @@
+module Such
+  def self.subclass(clss, sprclss="Gtk::#{clss}", body='include Such::Thing')
+    eval <<-CODE
+    class #{clss} < #{sprclss}
+      #{body}
+    end
+    CODE
+  end
+end

data/lib/such/thing.rb

@@ -0,0 +1,128 @@
+module Such
+  module Thing
+    INTOS = [:set_submenu, :pack_start, :append, :add] # TODO:GTK!?
+
+    PARAMETERS = {}
+    def self.configure(conf)
+      conf.each{|k,v| PARAMETERS[k]=v}
+    end
+
+    def self.trace_method(obj, mthd, args)
+      $stderr.puts "#{obj.class}##{mthd}(#{[*args].join(',')})"
+    end
+
+    def self.trace_signal(obj, signal)
+      $stderr.puts "#{obj.class} links #{signal}"
+    end
+
+    def self.do_symbol(parameter, parameters)
+      if PARAMETERS.has_key?(parameter)
+        p = PARAMETERS[parameter]
+        (parameter[-1]=='!')? parameters.unshift(*p) : parameters.unshift(p)
+      else
+        if parameter[-1]=='!'
+          p = parameter[0..-2]
+          parameters.unshift(p.downcase.to_sym)
+          parameters.unshift(p.upcase.to_sym)
+        else
+          warn "Warning: Such::PARAMETERS[#{parameter}] not defined"
+        end
+      end
+    end
+
+    def self.do_parameters(parameters)
+      container, arguments, methods, signals = nil, [], {}, []
+      while parameter = parameters.shift
+        case parameter
+        when Symbol
+          # Symbols are expected to translate to something else.
+          Thing.do_symbol(parameter, parameters)
+        when Array
+          # Arrays are added to the Thing's arguments list.
+          arguments += parameter
+        when Hash
+          # Hashes are expected to be a symbol list of methods on Thing with respective arguments.
+          # It's possible to override a previously defined method with new arguments.
+          parameter.each{|k,v| methods[k]=v}
+        when String
+          # Typically a signal: Thing#signal_connect(signal){|*emits| block.call(*emits)}
+          signals.push(parameter)
+        else
+          # Assume it's a container
+          container = parameter
+        end
+      end
+      signals.uniq!
+      return container, arguments, methods, signals
+    end
+
+    def self.which_method(container, methods=INTOS)
+      methods.each{|mthd| return mthd if container.respond_to?(mthd)}
+      raise "Don't know how to put into #{container.class}."
+    end
+
+    def self.into(obj, container=nil, mthd=nil, *args)
+      if container
+        mthd=Thing.which_method(container) unless mthd
+        unless mthd.class==Symbol and container.respond_to?(mthd)
+          raise "Need container & method. Got #{container.class}##{mthd}(#{obj.class}...)"
+        end
+        Thing.trace_method(container, mthd, [obj.class,*args]) if $VERBOSE
+        container.method(mthd).call(obj, *args)
+      else
+        warn "Warning: Container for #{self.class} not given."
+      end
+    end
+
+    def self.do_method(obj, mthd, *args)
+      Thing.trace_method(obj, mthd, args) if $VERBOSE
+      m = obj.method(mthd)
+      begin
+        m.call(*args)
+      rescue ArgumentError, TypeError
+        # Assume user meant to iterate. Note that the heuristic is not perfect.
+        $stderr.puts "# Iterated Method #{mthd} ^^^" if $VERBOSE
+        [*args].each{|arg| m.call(*arg)}
+        if $!.class == ArgumentError and not m.arity == 1
+          warn "Warning: Iterated method's arity not one."
+        end
+      end
+    end
+
+    def self.do_methods(obj, methods, container=nil)
+      # If user does not specify how to add to container, assume default way.
+      methods[:into]=Thing.which_method(container) if container and !methods.has_key?(:into)
+      methods.each do |mthd, args|
+        (mthd==:into)? Thing.into(obj, container, *args) :
+                       Thing.do_method(obj, mthd, *args)
+      end
+    end
+
+    def self.do_links(obj, signals, block)
+      none = (signals.length==0)
+      if block
+        signals.push('clicked') if block and none # TODO: GTK!?
+        signals.each do |signal|
+          Thing.trace_signal(obj, signal) if $VERBOSE
+          obj.signal_connect(signal){|*emits| block.call(*emits)} # TODO: GTK!?
+        end
+      elsif not none
+        warn "Warning: No block given for #{signals.join(',')} on #{obj.class}."
+      end
+    end
+
+    def self.do_config(obj, *parameters, &block)
+      container, arguments, methods, signals = Thing.do_parameters(parameters)
+      Thing.do_methods(obj, methods, container)
+      Thing.do_links(obj, signals, block)
+      warn "Warning: arguments not used in do_config(#{obj.class}...)." if arguments.length > 0
+    end
+
+    def initialize(*parameters, &block)
+      container, arguments, methods, signals = Thing.do_parameters(parameters)
+      super(*arguments)
+      Thing.do_methods(self, methods, container)
+      Thing.do_links(self, signals, block)
+    end
+  end
+end

data/lib/such/things.rb

@@ -0,0 +1,11 @@
+module Such
+  module Things
+    def self.list(clss=Gtk::Widget)
+      ObjectSpace.each_object(Class).select{|k| k < clss}
+    end
+
+    def self.gtk_widget
+      Things.list.each{|clss| Such.subclass(clss.name.sub('Gtk::',''))}
+    end
+  end
+end

data/lib/such/version.rb

@@ -0,0 +1,3 @@
+module Such
+  VERSION = '0.0.0'
+end

data/lib/such.rb

@@ -0,0 +1,6 @@
+require 'such/version'
+require 'such/thing'
+require 'such/such'
+require 'such/things'
+# Requires:
+#`ruby`

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: such
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- carlosjhr64
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-01 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Wraps Ruby's Gtk widgets with an alternate constructor
+  which factors out the configuration and assembly procedures into metadata.
+
+  And the _Such_ module can be used to wrap any class with the alternate constructor,
+  although currently only _Gtk3_ widgets is supported.
+email: carlosjhr64@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- lib/such.rb
+- lib/such/such.rb
+- lib/such/thing.rb
+- lib/such/things.rb
+- lib/such/version.rb
+homepage: https://github.com/carlosjhr64/such
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+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:
+- 'ruby: ruby 2.1.3p242 (2014-09-19 revision 47630) [x86_64-linux]'
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Wraps Ruby's Gtk widgets with an alternate constructor which factors out
+  the configuration and assembly procedures into metadata.
+test_files: []
+has_rdoc: