device_input 0.3.1.1 → 1.0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7e80de2a9de59a0076e1cc095f3ac1fe89ed0b46
-  data.tar.gz: bf28ea6f71a22ef4d66eb20bef8a7ffba58e179b
+SHA256:
+  metadata.gz: ad6579dcc34efa4420edde0db593da7023730451f37b805e98b438a271bfad36
+  data.tar.gz: d7dea2ee2567926f779fa0aca3bcccbbe6e84bce006dd51e275d8f3c163931b0
 SHA512:
-  metadata.gz: 06b933b69b255c4c23a26490c4a5de946bdf799f655674856ca312577d1e6971956fd0ade3038dbe08a7829c9d541cd1d26fa3bb3999c779d5877797360389f5
-  data.tar.gz: 7b59c9f09b816737662610fd9869af77299d9616efb39677de43a78f3690557decad7ca755b0833e3a2c3fad58995da76b624e12b9d94c91586011e0115f9f33
+  metadata.gz: fa18a6a3d85040cc87a25be1556cf288bbe7b42154606fe1f17bd587d53236fab9bd11faa9491194067a515addea23b5514138f6e8c1a30dcf77b92592676858
+  data.tar.gz: 56c653f912cbdcb3a054f56e920066245c6859e4f9e51ed83bfe7c4afd3bcefb6dad91e14a39118797a0045529028428e659bb551df90ed628d824c94f5c62f4

data/README.md

@@ -1,7 +1,5 @@
-[![Build Status](https://travis-ci.org/rickhull/device_input.svg?branch=master)](https://travis-ci.org/rickhull/device_input)
+[![CI Status](https://github.com/rickhull/device_input/actions/workflows/ci.yaml/badge.svg)](https://github.com/rickhull/device_input/actions/workflows/ci.yaml)
 [![Gem Version](https://badge.fury.io/rb/device_input.svg)](http://badge.fury.io/rb/device_input)
-[![Dependency Status](https://gemnasium.com/rickhull/device_input.svg)](https://gemnasium.com/rickhull/device_input)
-[![Security Status](https://hakiri.io/github/rickhull/device_input/master.svg)](https://hakiri.io/github/rickhull/device_input/master)
 [![Code Climate](https://codeclimate.com/github/rickhull/device_input/badges/gpa.svg)](https://codeclimate.com/github/rickhull/device_input)
 
 # Device Input
@@ -42,8 +40,7 @@ long time, it was pretty simple: events are 16 bytes:
 
 However, this is only true for 32-bit platforms.  On 64-bit platforms, event
 timestamps became 16 bytes, increasing the size of events from 16 to 24 bytes.
-This is because a timestamp is defined (ultimately) as two `long`s, and as
-everyone knows, two longs don't make a light.  No, wait -- it's that `long`s
+This is because a timestamp is defined (ultimately) as two `long`s, which
 are bigger on 64-bit platforms.  It's easy to remember:
 
 * 32-bit platform: 32-bit `long` (4 bytes)
@@ -61,7 +58,8 @@ executable code to assist in examining kernel input events.
 
 **REQUIREMENTS**
 
-* Ruby >= 2.0
+* Ruby >= 2.3
+* Earlier rubies are supported on pre-1.0 versions
 
 **DEPENDENCIES**
 
@@ -69,12 +67,12 @@ executable code to assist in examining kernel input events.
 
 Install the gem:
 ```shell
-$ gem install device_input # sudo as necessary
+$ gem install device_input
 ```
 
 Or, if using [Bundler](http://bundler.io/), add to your `Gemfile`:
 ```ruby
-gem 'device_input', '~> 0.3'
+gem 'device_input', '~> 1.0'
 ```
 
 # Usage
@@ -167,7 +165,7 @@ An event has:
 * `#value`: Fixnum (signed) from `#data`
 
 You will probably want to write your own read loop for your own project.
-[`DeviceInput.read_loop`](lib/device_input.rb#L102) is very simple and can
+[`DeviceInput.read_loop`](lib/device_input.rb#L98) is very simple and can
 easily be rewritten outside of this project's namespace and adapted for your
 needs.
 
@@ -178,10 +176,7 @@ needs.
 * https://www.kernel.org/doc/Documentation/input/input.txt
 * https://www.kernel.org/doc/Documentation/input/event-codes.txt
 
-These events are defined as C structs with a fixed size in bytes.  See more
-about these structs towards the end of this document.
-
-## Kernel structs
+### Kernel structs
 
 from https://www.kernel.org/doc/Documentation/input/input.txt
 ```

data/Rakefile

@@ -0,0 +1,120 @@
+require 'rake/testtask'
+desc "Run tests"
+Rake::TestTask.new :test do |t|
+  t.pattern = 'test/*.rb'
+  t.warning = true
+end
+
+task default: :test
+
+
+#
+# METRICS
+#
+
+metrics_tasks = []
+
+begin
+  require 'flog_task'
+
+  # we want: flog --all --methods-only lib
+  # but: FlogTask doesn't support the equivalent of --all; oh well
+  methods_only = true
+  FlogTask.new(:flog, 200, ['lib'], nil, methods_only) do |t|
+    t.verbose = true
+  end
+  metrics_tasks << :flog
+rescue LoadError
+  warn 'flog_task unavailable'
+end
+
+begin
+  require 'flay_task'
+
+  # we want: flay --liberal lib
+  # but: FlayTask doesn't support the equivalent of --liberal; oh well
+  FlayTask.new do |t|
+    t.dirs = ['lib']
+    t.verbose = true
+  end
+  metrics_tasks << :flay
+rescue LoadError
+  warn 'flay_task unavailable'
+end
+
+begin
+  require 'roodi_task'
+  RoodiTask.new patterns: ['lib/**/*.rb']
+  metrics_tasks << :roodi
+rescue LoadError
+  warn 'roodi_task unavailable'
+end
+
+desc "Generate code metrics reports"
+task :code_metrics => metrics_tasks
+
+
+#
+# PROFILING
+#
+
+desc "Show current system load"
+task "loadavg" do
+  puts File.read "/proc/loadavg"
+end
+
+# make sure command is run against lib/ on the filesystem, not an installed gem
+def lib_sh(cmd)
+  sh "RUBYLIB=lib #{cmd}"
+end
+
+# set up script, args, and rprof_args the way ruby-prof wants them
+def rprof_sh(script, args, rprof_args = '')
+  lib_sh ['ruby-prof', rprof_args, script, '--', args].join(' ')
+end
+
+rprof_options = {
+  min_percent: 2,
+  printer: :graph,
+  mode: :process,
+  sort: :self,
+}.inject('') { |memo, (flag,val)| memo + "--#{flag}=#{val} " }
+
+evdump_options = {
+  count: 9999,
+  print: 'off',
+}.inject('') { |memo, (flag,val)| memo + "--#{flag} #{val} " } + '/dev/zero'
+
+desc "Run ruby-prof on bin/evdump (9999 events)"
+task "ruby-prof" => "loadavg" do
+  puts
+  rprof_sh 'bin/evdump', evdump_options, rprof_options
+end
+
+desc "Run ruby-prof with --exclude-common-cycles"
+task "ruby-prof-exclude" => "ruby-prof" do
+  puts
+  rprof_sh 'bin/evdump', evdump_options,
+           "#{rprof_options} --exclude-common-cycles"
+end
+
+task "no-prof" do
+  lib_sh "bin/evdump #{evdump_options}"
+end
+
+
+#
+# GEM BUILD / PUBLISH
+#
+
+begin
+  require 'buildar'
+
+  Buildar.new do |b|
+    b.gemspec_file = 'device_input.gemspec'
+    b.version_file = 'VERSION'
+    b.use_git = true
+  end
+rescue LoadError
+  # ok
+end

data/VERSION

@@ -1 +1 @@
-0.3.1.1
+1.0.1.1

data/device_input.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.name = 'device_input'
+  s.summary = 'Read input events from e.g. /dev/input/event0'
+  s.description = <<EOF
+Pure ruby to read input events from the Linux kernel input device subsystem.
+No dependencies.  Ruby 2+ required
+EOF
+  s.authors = ["Rick Hull"]
+  s.homepage = 'https://github.com/rickhull/device_input'
+  s.license = 'GPL-3.0'
+
+  s.required_ruby_version = ">= 2.3"
+
+  s.version = File.read(File.join(__dir__, 'VERSION')).chomp
+
+  s.files  = %w[device_input.gemspec VERSION README.md Rakefile]
+  s.files += Dir['lib/**/*.rb']
+  s.files += Dir['test/**/*.rb']
+  s.files += Dir['bin/**/*.rb']
+
+  s.executables = ['evdump']
+
+  s.add_runtime_dependency 'slop', '~> 4.0'
+end

data/lib/device_input.rb

@@ -1,5 +1,5 @@
 require 'device_input/labels'
-require 'device_input/compat'
+require 'rbconfig/sizeof'
 
 module DeviceInput
   class Event
@@ -80,19 +80,14 @@ module DeviceInput
     end
 
     # display fields in hex
-    def ruby23_hex
-      # :nocov:
-      require 'rbconfig/sizeof'  # new in ruby 2.3
+    def hex
       DEFINITION.inject('') { |memo, (field, type)|
         int = @data.send(field)
         width = RbConfig::SIZEOF.fetch(type)
         # memo + ("%#0.#{width * 2}x" % int) + " "
         memo + ("%0.#{width * 2}x" % int) + " "
       }
-      # :nocov:
     end
-
-    alias_method :hex, RUBY23 ? :ruby23_hex : :to_s
   end
 
   def self.read_loop(io)

data/test/device_input.rb

@@ -0,0 +1,98 @@
+require_relative 'helper.rb'
+
+require 'device_input'
+
+describe DeviceInput::Event do
+  E = DeviceInput::Event
+
+  describe "type_labels" do
+    it "must return an array of strings" do
+      dne = E.type_labels(:does_not_exist)
+      expect(dne).must_be_instance_of(Array)
+      expect(dne.first).must_be_instance_of(String)
+      expect(dne.last).must_be_instance_of(String)
+
+      # 0 is EV_SYN
+      de = E.type_labels(0)
+      expect(de).must_be_instance_of(Array)
+      expect(de.first).must_be_instance_of(String)
+      expect(de.last).must_be_instance_of(String)
+    end
+  end
+
+  describe "code_labels" do
+    it "must return an array of strings" do
+      dne = E.code_labels(:does_not_exist, nil)
+      expect(dne).must_be_instance_of(Array)
+      expect(dne.first).must_be_instance_of(String)
+      expect(dne.last).must_be_instance_of(String)
+
+      # 0,0 = EV_SYN,SYN_REPORT
+      de = E.code_labels(0, 0)
+      expect(de).must_be_instance_of(Array)
+      expect(de.first).must_be_instance_of(String)
+      expect(de.last).must_be_instance_of(String)
+    end
+  end
+
+  describe "encode" do
+    it "must return a string" do
+      expect(E.encode(E::NULL_DATA)).must_be_instance_of(String)
+    end
+  end
+
+  describe "decode" do
+    it "must return a Data (struct)" do
+      expect(E.decode(E::NULL_MSG)).must_be_instance_of(E::Data)
+    end
+  end
+
+  describe "new instance" do
+    before do
+      @event = E.new(E::NULL_DATA)
+    end
+
+    it "must have data" do
+      expect(@event.data).must_be_instance_of(E::Data)
+    end
+
+    it "must have a timestamp" do
+      expect(@event.time).must_be_instance_of(Time)
+    end
+
+    it "must have a type" do
+      expect(@event.type).must_be_instance_of(String)
+    end
+
+    it "must have a code" do
+      expect(@event.code).must_be_instance_of(String)
+    end
+
+    it "must have a value" do
+      expect(@event.value).must_be_kind_of(Integer)
+    end
+
+    it "must have string representations" do
+      [:to_s, :pretty, :raw, :hex].each { |meth|
+        expect(@event.send(meth)).must_be_instance_of(String)
+      }
+    end
+  end
+end
+
+describe DeviceInput do
+  describe "read_loop" do
+    before do
+      @io = StringIO.new("\x00" * 64)
+    end
+
+    it "must read at least one message from an io with 64 bytes" do
+      events = []
+      DeviceInput.read_loop(@io) { |event|
+        events << event
+      }
+      expect(events).wont_be_empty
+      expect(events.first).must_be_instance_of(E)
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,51 @@
+if ENV['CODE_COVERAGE'] and
+  !%w[false no].include?(ENV['CODE_COVERAGE'].downcase)
+
+  require 'simplecov'
+  require 'simplecov_json_formatter'
+
+  class SimpleCov::Formatter::TextFormatter
+    FILENAME = 'metrics/coverage'
+
+    def format(result)
+      tot = result.files
+      rpt = ["Coverage: %0.1f%%" % tot.covered_percent,
+             "Strength: %0.2f" % tot.covered_strength,
+             "   Lines: %i" % tot.lines_of_code,
+             " Covered: %i" % tot.covered_lines,
+             "     N/A: %i" % tot.never_lines,
+            ]
+      if tot.missed_lines > 0
+        rpt << "Missed: %i" % tot.missed_lines
+      end
+      if tot.skipped_lines > 0
+        rpt << "Skipped: %i" % tot.skipped_lines
+      end
+      rpt << result.files.map { |sfile|
+        "%i%% (%i/%i)\t%s" % [sfile.covered_percent,
+                              sfile.covered_lines.length,
+                              sfile.lines_of_code,
+                              sfile.filename]
+      }.join("\n")
+      rpt = rpt.join("\n")
+
+      puts
+      puts rpt
+      if File.writable?(FILENAME)
+        File.open(FILENAME, 'w') { |f|
+          f.write(rpt + "\n")
+        }
+        puts "wrote #{FILENAME}"
+      end
+    end
+  end
+
+  SimpleCov.formatters = [
+    SimpleCov::Formatter::TextFormatter,
+    SimpleCov::Formatter::JSONFormatter,
+  ]
+
+  SimpleCov.start
+end
+
+require 'minitest/autorun'

metadata

@@ -1,80 +1,68 @@
 --- !ruby/object:Gem::Specification
 name: device_input
 version: !ruby/object:Gem::Version
-  version: 0.3.1.1
+  version: 1.0.1.1
 platform: ruby
 authors:
 - Rick Hull
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-03-02 00:00:00.000000000 Z
+date: 1980-01-01 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: buildar
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
 - !ruby/object:Gem::Dependency
   name: slop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
-  type: :development
+        version: '4.0'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4'
+        version: '4.0'
 description: |
   Pure ruby to read input events from the Linux kernel input device subsystem.
   No dependencies.  Ruby 2+ required
-email: 
+email:
 executables:
 - evdump
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- Rakefile
 - VERSION
 - bin/evdump
+- device_input.gemspec
 - lib/device_input.rb
-- lib/device_input/compat.rb
 - lib/device_input/labels.rb
+- test/device_input.rb
+- test/helper.rb
 homepage: https://github.com/rickhull/device_input
 licenses:
 - GPL-3.0
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '2'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
-signing_key: 
+rubygems_version: 3.4.4
+signing_key:
 specification_version: 4
 summary: Read input events from e.g. /dev/input/event0
 test_files: []

data/lib/device_input/compat.rb

@@ -1,24 +0,0 @@
-require 'device_input/labels'
-
-# :nocov:
-module DeviceInput
-  if RbConfig::CONFIG.fetch("MAJOR").to_i < 2
-    raise "unsupported ruby version #{RbConfig::CONFIG['RUBY_VERSION_NAME']}"
-  else
-    RUBY23 = RbConfig::CONFIG.fetch("MINOR").to_i >= 3
-  end
-
-  unless RUBY23
-    class Event
-      def CODES.dig(*args)
-        memo = self
-        args.each { |a|
-          memo = memo[a] rescue nil
-          break unless memo
-        }
-        memo
-      end
-    end
-  end
-end
-# :nocov: