such 0.2.0 → 2.0.210201

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 2aa58153d86bf6074ae44f9ddb9b0d75f2974425
-  data.tar.gz: b62521c79d8f591ce2bfd0cd7365ab419c8bb99c
+SHA256:
+  metadata.gz: 84767a253e3e1535798068135516617e3c198fc4b3ed756e529c16c27f25a649
+  data.tar.gz: 919ffcc84f13208bb3fc232ad8dc2ac92eb16b40d0cc6f63bb81b2b79c8b7e63
 SHA512:
-  metadata.gz: 784228d9e8176604fcb782f4a4ebca93d58e80292b261cf624659f1d5595e9cb089aa8f21dcabb106ef41eb3d44dc2ca8e3c020e6bacc682b325b86bff02abe7
-  data.tar.gz: 3298e0be3b96149b0433fc59cd54b9934338ecb7cd1befeff07e3153c45d2671ebd48bf34b468194861bcab16791b49e2f16ea846dfd68fbc9e7909a7bdc0fd7
+  metadata.gz: d53f03a3dc85ad766199e40d0f7d08011420ec1c437de865cdda76f2757a8c4bac012379098fd087af1f78ce11918be949b46fe0cff68668806df237a175a5f0
+  data.tar.gz: 96c391adf17465cdf4330a37c83eece66a1d4ae37337067fc8b04cd1f0105fe5f4b45b4863371c60d558552980e5ab744f9cb817c4c26322895b50139567760a

data/{README.rdoc → README.md}

@@ -1,54 +1,77 @@
-= Such
+# Such
 
-== DESCRIPTION:
+* [VERSION 2.0.210201](https://github.com/carlosjhr64/such/releases)
+* [github](https://www.github.com/carlosjhr64/such)
+* [rubygems](https://rubygems.org/gems/such)
 
-Wraps Ruby's Gtk widgets with an alternate constructor
+## DESCRIPTION:
+
+Wraps widgets with an alternate constructor
 which factors out the configuration and assembly procedures into metadata.
+Can be used to wrap any class with the alternate constructor,
+although targeted only Gtk3 widgets.
+
+## INSTALL:
 
-And the _Such_ module can be used to wrap any class with the alternate constructor,
-although currently only _Gtk3_ widgets is supported.
+```shell
+$ sudo gem install such
+```
 
-== SYNOPSIS:
+## SYNOPSIS:
 
-   require 'gtk3'
-   require 'such'
-   include Such; Things.gtk_widget
+```ruby
+require 'gtk3'
+require 'such'
+include Such; Things.in Gtk::Widget
 
-   Thing.configure window: {
-                     set_title: 'Synopsis Example',
-                     set_window_position: :center },
-                   BUTTON: [label: 'Button!'],
-                   button: {set_size_request: [100,50], into:[:add]}
+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
+window = Window.new(:window, 'destroy'){Gtk.main_quit} #~> Such::Window
+Button.new(window, :button!){puts 'Button pressed!'}   #~> Such::Button
+window.show_all
 
-   Gtk.main
+Gtk.main #=> nil
+```
 
-== MORE:
+## 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'}
+```ruby
+Such::Button.new(
+  window,
+  [label: 'Hello!'],
+  {set_size_request:[100,50]},
+  'clicked'
+  ){ puts 'OK'}
 
-   # Is equivalent to
+# Is equivalent to:
 
-   button = Gtk::Button.new(label:'Hello!')
-   window.add button
-   button.set_size_request 100, 50
-   button.signal_connect('clicked'){puts 'OK'}
+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:
+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)
+```ruby
+{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:
 
+```ruby
    Thing.configure(
      KEY: [ arg1, arg2, arg3 ], # an array for super(arg1, arg2, arg3)
      key: {                     # a hash for like self.method(args)
@@ -58,11 +81,12 @@ One can configure Symbol keys to represent metadata about a widget:
      },
      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/].
+ZetCode.com[http://zetcode.com/gui/rubygtk/] (back in 2015).
 
-=== Features:
+## Features:
 
 * :key! content *splat
 * Undefined :key! expanded to :KEY, :key
@@ -71,21 +95,17 @@ ZetCode.com[http://zetcode.com/gui/rubygtk/].
 * Packing method defaults (ultimately) to :add
 * Way to change default packing behaviour
 
-== INSTALL:
-
-  $ sudo gem install such
-
-== But wait!  One more thing:
+## But wait!  One more thing:
 
-See link:examples/such_parts_demo in the examples directory
-and link:test/tc_part for hints on how to use the much poweful
-Such::Part module link:lib/such/part.rb
+See [such_parts_demo](examples/such_parts_demo) in the examples directory
+and [tc_part](test/tc_part) for hints on how to use the powerful
+[Such::Part module](lib/such/part.rb).
 
-== LICENSE:
+## LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2014 
+Copyright (c) 2021 CarlosJHR64
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/such.rb

@@ -1,8 +1,10 @@
-require 'such/version'
-require 'such/thing'
-require 'such/part'
+module Such
+  VERSION = '2.0.210201'
+end
 require 'such/such'
+require 'such/thing'
 require 'such/things'
+require 'such/part'
 require 'such/parts'
 # Requires:
 #`ruby`

data/lib/such/part.rb

@@ -1,29 +1,33 @@
 module Such
   module Part
+    PLUG_PATTERN = /^(?<sym>[^\W_]+)_(?<cls>[^\W_]+)$/
+
     def initialize(*parameters, &block)
       super(*parameters)
       self.class.plugs.each do |plg|
-        if /^(?<sym>[^\W_]+)_(?<cls>[^\W_]+)$/=~plg
-          plg, sym, cls = method("#{plg}="), "#{sym}!".to_sym, Object.const_get("Such::#{cls}")
-          plg.call cls.new(self, sym, &block)
+        if md = PLUG_PATTERN.match(plg)
+          plg, sym, cls = "#{plg}=".to_sym, "#{md[:sym]}!".to_sym, Object.const_get("Such::#{md[:cls]}")
+          # self.<plg> = Such::<cls>.new(self, :<sym>!, &block)
+          public_send plg, cls.new(self, sym, &block)
         end
       end
     end
 
     def message(*parameters)
-      self.class.plugs.each{|plg| method(plg).call.message(*parameters)}
+      self.class.plugs.each{|plg| public_send(plg).message(*parameters) }
     end
 
-    def method_missing(plug,*args) # assuming a plug
-      super unless args.length==0 and plug=~/^[^\W_]+_[^\W_]+$/
-      obj = nil
-      self.class.plugs.each do |plg|
-        plug = method(plg).call
-        if plug.is_a? Such::Part
-          break if obj = plug.method(plg).call
+    def method_missing(maybe,*args) # maybe a plug down the plugged things.
+      super unless args.length==0 and PLUG_PATTERN.match?(maybe)
+      self.class.plugs.each do |plug|
+        thing = public_send(plug)
+        if thing.is_a? Such::Part
+          if obj = thing.public_send(maybe)
+            return obj
+          end
         end
       end
-      return obj
+      return nil
     end
   end
 end

data/lib/such/parts.rb

@@ -1,7 +1,9 @@
 module Such
   module Parts
     def self.make(part, thing, *plugs)
-      raise "Such::#{thing} not defined." unless Object.const_defined?("Such::#{thing}")
+      unless thing < Such::Thing and [part,*plugs].all?{_1.is_a? Symbol}
+        raise "Expected Such::Parts.make(Symbol part, Class thing < Such::Thing, *Symbol plugs)"
+      end
       plugs.each do |plug|
         if /^[^\W_]+_(?<klass>[^\W_]+)$/=~plug
           next unless $VERBOSE
@@ -12,13 +14,9 @@ module Such
           raise "Plugs must have the form key_class: #{plug}"
         end
       end
-      Such.subclass part, thing,  <<-EOT
-        attr_accessor :#{plugs.join(', :')}
-        def self.plugs
-          [:#{plugs.join(', :')}]
-        end
-        include Such::Part
-      EOT
+      subklass = Such.subclass(part, thing, include: Such::Part, attr_accessor: plugs)
+      subklass.singleton_class.class_eval{ define_method(:plugs){plugs} }
+      return subklass
     end
   end
 end

data/lib/such/such.rb

@@ -1,9 +1,8 @@
 module Such
-  def self.subclass(clss, sprclss="Gtk::#{clss}", body='include Such::Thing')
-    eval <<-CODE
-    class #{clss} < #{sprclss}
-      #{body}
-    end
-    CODE
+  def self.subclass(name, klass, **kw, &block)
+    subklass = const_set(name, Class.new(klass))
+    kw.each{|method, args| subklass.public_send(method, *args)}
+    subklass.class_eval(&block) if block
+    return subklass
   end
 end

data/lib/such/thing.rb

@@ -1,10 +1,14 @@
 module Such
   module Thing
-    INTOS = [:set_submenu, :pack_start, :append, :add] # TODO:GTK!?
+    SIGNALS = ['clicked']
+    INTOS   = [:set_submenu, :pack_start, :append, :add]
 
-    PARAMETERS = {}
+    # PARAMETERS' pretense of being a Hash constant :P
+    @@PARAMETERS = {}
+    PARAMETERS = lambda{|k| @@PARAMETERS[k]}
+    def PARAMETERS.to_h = @@PARAMETERS
     def self.configure(conf)
-      conf.each{|k,v| PARAMETERS[k]=v}
+      @@PARAMETERS = conf
     end
 
     def self.trace_method(obj, mthd, args)
@@ -16,8 +20,8 @@ module Such
     end
 
     def self.do_symbol(parameter, parameters)
-      if PARAMETERS.has_key?(parameter)
-        p = PARAMETERS[parameter]
+      if @@PARAMETERS.has_key?(parameter)
+        p = @@PARAMETERS[parameter]
         (parameter[-1]=='!')? parameters.unshift(*p) : parameters.unshift(p)
       else
         if parameter[-1]=='!'
@@ -25,7 +29,7 @@ module Such
           parameters.unshift(p.downcase.to_sym)
           parameters.unshift(p.upcase.to_sym)
         else
-          warn "Warning: Such::PARAMETERS[#{parameter}] not defined"
+          warn "Warning: Such::Thing::PARAMETERS[#{parameter}] not defined"
         end
       end
     end
@@ -36,17 +40,17 @@ module Such
         case parameter
         when Symbol
           # Symbols are expected to translate to something else.
-          Thing.do_symbol(parameter, parameters)
+          Thing.do_symbol parameter, parameters
         when Array
           # Arrays are added to the Thing's arguments list.
-          arguments += parameter
+          arguments.concat 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}
+          methods.merge! parameter
         when String
           # Typically a signal: Thing#signal_connect(signal){|*emits| block.call(*emits)}
-          signals.push(parameter)
+          signals.push parameter
         else
           # Assume it's a container
           container = parameter
@@ -57,18 +61,22 @@ module Such
     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}."
+      mthd = methods.detect{|m| container.respond_to?(m)}
+      raise "Don't know how to put into #{container.class}." if mthd.nil?
+      return mthd
     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}...)"
+        if mthd
+          unless mthd.class==Symbol and container.respond_to?(mthd)
+            raise "Need container & method. Got #{container.class}##{mthd}(#{obj.class}...)"
+          end
+        else
+          mthd=Thing.which_method(container)
         end
         Thing.trace_method(container, mthd, [obj.class,*args]) if $VERBOSE
-        container.method(mthd).call(obj, *args)
+        container.public_send(mthd, obj, *args)
       else
         warn "Warning: Container for #{self.class} not given."
       end
@@ -81,17 +89,14 @@ module Such
         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
+        $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[:into]=Thing.which_method(container) if container and not methods.has_key?(:into)
       methods.each do |mthd, args|
         (mthd==:into)? Thing.into(obj, container, *args) :
                        Thing.do_method(obj, mthd, *args)
@@ -99,16 +104,17 @@ module Such
     end
 
     def self.do_links(obj, signals, block)
+      return if signals.first==''
       none = (signals.length==0)
       if block
-        signals.push('clicked') if block and none # TODO: GTK!?
+        signals.push(*SIGNALS) if none
         signals.each do |signal|
           break if signal==''
           begin
-            obj.signal_connect(signal){|*emits| block.call(*emits, signal)} # TODO: GTK!?
+            obj.signal_connect(signal){|*emits| block.call(*emits, signal)}
             Thing.trace_signal(obj, signal) if $VERBOSE
           rescue GLib::NoSignalError
-            warn "Warning: no \"#{signal}\" signal for #{obj.class}"
+            warn "Warning: no #{signal} signal for #{obj.class}"
           end
         end
       elsif not none

data/lib/such/things.rb

@@ -1,11 +1,21 @@
 module Such
   module Things
-    def self.list(clss=Gtk::Widget)
-      ObjectSpace.each_object(Class).select{|k| k < clss}
+    def self.list(superklass)
+      ObjectSpace.each_object(Class).select{|klass| klass < superklass}
     end
 
-    def self.gtk_widget
-      Things.list.each{|clss| Such.subclass(clss.name.sub('Gtk::',''))}
+    def self.subclass(klass)
+      Such.subclass(klass.name.sub(/^.*::/,'').to_sym, klass, include: Such::Thing)
+    end
+
+    def self.in(superklass)
+      Things.list(superklass).each do |klass|
+        begin
+          Things.subclass(klass)
+        rescue
+          $stderr.puts "#{$!.class}:\t#{superklass}" if $VERBOSE
+        end
+      end
     end
   end
 end

metadata

@@ -1,43 +1,38 @@
 --- !ruby/object:Gem::Specification
 name: such
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 2.0.210201
 platform: ruby
 authors:
 - carlosjhr64
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-11-24 00:00:00.000000000 Z
+date: 2021-02-01 00:00:00.000000000 Z
 dependencies: []
 description: |
-  Wraps Ruby's Gtk widgets with an alternate constructor
+  Wraps 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.
+  Can be used to wrap any class with the alternate constructor,
+  although targeted only Gtk3 widgets.
 email: carlosjhr64@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.rdoc
+extra_rdoc_files: []
 files:
-- README.rdoc
+- README.md
 - lib/such.rb
 - lib/such/part.rb
 - lib/such/parts.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
+post_install_message:
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -51,12 +46,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !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: 
+- 'ruby: ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-linux]'
+rubygems_version: 3.2.3
+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.
+summary: Wraps widgets with an alternate constructor which factors out the configuration
+  and assembly procedures into metadata. Can be used to wrap any class with the alternate
+  constructor, although targeted only Gtk3 widgets.
 test_files: []
-has_rdoc: 

data/lib/such/version.rb

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