such 0.4.0 → 1.0.210117

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 69f8edd38b0a7e373c70c896c47a08c629af311a
-  data.tar.gz: 72b897561c138e4efc85facdc39300f5b27a3386
+SHA256:
+  metadata.gz: 8455f46116268e25b466323fb8d75b76d6084c815b8007a5d7d8cd934a15758d
+  data.tar.gz: 577f05b1c0bc9d4d3a1a93ee58103f7656243dbd064ed7d887cec899a3de47e6
 SHA512:
-  metadata.gz: e9f866da5f5971f67cee50008942332fcdb2e3377b81ba4e7ee30d0b5dc1ed3ef223e7706a8f4f0627bdfe3b65dd57a188c69ea167ee3b11f4ebe803263caf08
-  data.tar.gz: 0452ec9e456484ec83b53103c766288e71c1d9d12ca38b63d4d745af3ae578a797263462dfacf61f5505757299e8e0937b99ed2af0ad5574aefa16374d5ccf2b
+  metadata.gz: c008f4588f1ea74638d76279d0f7ccc9ffd1a9f321e2cbd32d14bf0ad5e7da70903995b03d9820cf4a95af302269b5d99c9bf952fa7a346aebc77724d9091ddf
+  data.tar.gz: 8cce6a2ce219fe0f9a435f9d4236cb24ba28d60e62b585eb53cd2aa49bb9aacdf5ae43d29a864c761d472ded4cd02a3dca989c3a24b19dd8b5bc40658e303417

data/{README.rdoc → README.md}

@@ -1,53 +1,77 @@
-= Such
+# Such
 
-== DESCRIPTION:
+* [VERSION 1.0.210117](https://github.com/carlosjhr64/such/releases)
+* [github](https://www.github.com/carlosjhr64/such)
+* [rubygems](https://rubygems.org/gems/such)
+
+## 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 currently only Gtk3 widgets is supported.
+although targeted only Gtk3 widgets.
+
+## INSTALL:
+
+```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)
@@ -57,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/] (back in 2015).
 
-=== Features:
+## Features:
 
 * :key! content *splat
 * Undefined :key! expanded to :KEY, :key
@@ -70,21 +95,17 @@ ZetCode.com[http://zetcode.com/gui/rubygtk/] (back in 2015).
 * 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 powerful
-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) 2017
+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,8 @@
 module Such
-  VERSION = '0.4.0'
+  VERSION = '1.0.210117'
 end
-require 'such/thing'
 require 'such/such'
+require 'such/thing'
 require 'such/things'
 require 'such/part'
 require 'such/parts'

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,15 +1,8 @@
 module Such
-  def self.subclass(clss, sprclss="Gtk::#{clss}", body='include Such::Thing')
-    code = <<-CODE
-      class #{clss} < #{sprclss}
-        #{body}
-      end
-    CODE
-    begin
-      eval code
-    rescue Exception
-      $stderr.puts code if $VERBOSE
-      raise $!
-    end
+  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,11 @@
 module Such
   module Thing
-    INTOS = [:set_submenu, :pack_start, :append, :add] # TODO:TK!?
+    SIGNALS = ['clicked']
+    INTOS   = [:set_submenu, :pack_start, :append, :add]
 
     PARAMETERS = {}
     def self.configure(conf)
-      conf.each{|k,v| PARAMETERS[k]=v}
+      PARAMETERS.merge! conf
     end
 
     def self.trace_method(obj, mthd, args)
@@ -36,17 +37,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
@@ -72,7 +73,7 @@ module Such
           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
@@ -92,7 +93,7 @@ module Such
 
     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)
@@ -103,14 +104,14 @@ module Such
       return if signals.first==''
       none = (signals.length==0)
       if block
-        signals.push('clicked') if block and none # TODO: TK!?
+        signals.push(*SIGNALS) if none
         signals.each do |signal|
           break if signal==''
           begin
-            obj.signal_connect(signal){|*emits| block.call(*emits, signal)} # TODO: TK!?
+            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,21 +1,21 @@
 module Such
   module Things
-    def self.list(klss)
-      ObjectSpace.each_object(Class).select{|k| k < klss}
+    def self.list(superklass)
+      ObjectSpace.each_object(Class).select{|klass| klass < superklass}
     end
 
-    def self.in(klass)
-      Things.list(klass).each do |clss|
+    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
-          Such.subclass(clss.name.sub(/^.*::/, ''))
-        rescue Exception
-          $stderr.puts "#{$!.class}:\t#{clss}" if $VERBOSE
+          Things.subclass(klass)
+        rescue
+          $stderr.puts "#{$!.class}:\t#{superklass}" if $VERBOSE
         end
       end
     end
-
-    def self.gtk_widget
-      Things.in(Gtk::Widget)
-    end
   end
 end

metadata

@@ -1,27 +1,26 @@
 --- !ruby/object:Gem::Specification
 name: such
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.210117
 platform: ruby
 authors:
 - carlosjhr64
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-07-31 00:00:00.000000000 Z
+date: 2021-01-17 00:00:00.000000000 Z
 dependencies: []
 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 currently only Gtk3 widgets is supported.
+  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
@@ -32,10 +31,8 @@ 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
@@ -49,12 +46,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
-- 'ruby: ruby 2.4.1p111 (2017-03-22 revision 58053) [x86_64-linux]'
-rubyforge_project: 
-rubygems_version: 2.6.11
-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 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 currently only Gtk3 widgets is supported.
+  constructor, although targeted only Gtk3 widgets.
 test_files: []