tins 1.43.0 → 1.44.1

data/.github/workflows/codeql-analysis.yml

@@ -1,72 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ master ]
-  schedule:
-    - cron: '37 18 * * 5'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'ruby' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        
-        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
-        # queries: security-extended,security-and-quality
-
-        
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
-
-    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
-    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
-
-    # - run: |
-    #   echo "Run, Build Application using script"
-    #   ./location_of_script_within_repo/buildscript.sh
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2

data/lib/tins/count_by.rb

@@ -1,21 +0,0 @@
-require 'tins/string_version'
-
-module Tins
-  module CountBy
-    if Tins::StringVersion.compare(RUBY_VERSION, :<=, "1.8")
-      def count_by(&block)
-        block ||= lambda { |x| true }
-        inject(0) { |s, e| s += 1 if block.call(e); s }
-      end
-    else
-      require 'tins/deprecate'
-      extend Tins::Deprecate
-
-      deprecate method:
-        def count_by(&block)
-          count(&block)
-        end,
-        new_method: :count
-    end
-  end
-end

data/lib/tins/deep_const_get.rb

@@ -1,64 +0,0 @@
-require 'tins/string_version'
-
-module Tins
-  module DeepConstGet
-    class << self
-      if ::Object.method(:const_defined?).arity == 1
-        # :nocov:
-        # We do not create coverage on 1.8
-        def const_defined_in?(modul, constant)
-          modul.const_defined?(constant)
-        end
-        # :nocov:
-      else
-        require 'tins/deprecate'
-        extend Tins::Deprecate
-
-        deprecate method:
-          def const_defined_in?(modul, constant)
-            modul.const_defined?(constant, false)
-          end,
-          new_method: :const_defined?
-      end
-
-      if Tins::StringVersion.compare(RUBY_VERSION, :<, '2.0')
-        def deep_const_get(path, start_module = Object)
-          path.to_s.split('::').inject(start_module) do |p, c|
-            case
-            when c.empty?
-              if start_module == Object
-                Object
-              else
-                raise ArgumentError, "top level constants cannot be reached from"\
-                  " start module #{start_module.inspect}"
-              end
-            when const_defined_in?(p, c)
-              p.const_get(c)
-            else
-              begin
-                p.const_missing(c)
-              rescue NameError => e
-                raise ArgumentError, "can't get const #{path}: #{e}"
-              end
-            end
-          end
-        end
-      else
-        require 'tins/deprecate'
-        extend Tins::Deprecate
-
-        deprecate method:
-          def deep_const_get(path, start_module = Object)
-            start_module.const_get(path)
-          rescue NameError => e
-            raise ArgumentError, "can't get const #{path}: #{e}"
-          end,
-          new_method: :const_get
-      end
-    end
-
-    def deep_const_get(path, start_module = Object)
-      ::Tins::DeepConstGet.deep_const_get(path, start_module)
-    end
-  end
-end

data/lib/tins/timed_cache.rb

@@ -1,51 +0,0 @@
-class TimedCache
-  class Value < Struct.new(:value, :timestamp)
-    def self.json_create(hash)
-      new(*hash.values_at('value', 'timestamp'))
-    end
-
-    def as_json(*)
-      super | { JSON.create_id => self.class.name }
-    end
-  end
-
-  def initialize(name, ttl: 60, jitter: 1..5, &block)
-    @name   = name
-    @ttl    = ttl
-    @jitter = jitter
-    block or raise ArgumentError, 'block is required'
-    @block = block
-    @redis = Redis.new
-  end
-
-  def namespaced(key)
-    "timed_cache:#{key}"
-  end
-
-  def value
-    now = Time.now
-    if stored = stored_value
-      if (now - @ttl).to_i >= stored.timestamp
-        Thread.new {
-          sleep @jitter
-          if stored_value.timestamp <= stored.timestamp
-            @redis.set namespaced(@name), new_value(now).to_json
-          end
-        }
-      end
-      stored.value
-    else
-      nv = new_value(now)
-      @redis.set namespaced(@name), nv.to_json
-      nv.value
-    end
-  end
-
-  def new_value(now)
-    Value.new(@block.(), now.to_i)
-  end
-
-  def stored_value
-    @redis.get(namespaced(@name)).full? { |s| ::JSON.parse(s, create_additions: true) rescue nil }
-  end
-end

data/lib/tins/uniq_by.rb

@@ -1,23 +0,0 @@
-require 'tins/string_version'
-
-module Tins
-  module UniqBy
-    if Tins::StringVersion.compare(RUBY_VERSION, :<=, "1.8")
-      def uniq_by(&block)
-        block ||= lambda { |x| x }
-        inject({}) { |h, e| h[ block.call(e) ] ||= e; h }.values
-      end
-    else
-      require 'tins/deprecate'
-      extend Tins::Deprecate
-
-      deprecate method:
-        def uniq_by(&block)
-          uniq(&block)
-        end,
-        new_method: :uniq
-    end
-  end
-end
-
-require 'tins/alias'

data/lib/tins/xt/count_by.rb

@@ -1,7 +0,0 @@
-require 'tins/count_by'
-
-module Tins
-  module ::Enumerable
-    include CountBy
-  end
-end

data/lib/tins/xt/deep_const_get.rb

@@ -1,7 +0,0 @@
-require 'tins/deep_const_get'
-
-module Tins
-  class ::Object
-    include DeepConstGet
-  end
-end

data/lib/tins/xt/uniq_by.rb

@@ -1,25 +0,0 @@
-require 'tins/string_version'
-require 'tins/uniq_by'
-
-module Tins
-  module ::Enumerable
-    include UniqBy
-  end
-
-  class ::Array
-    if Tins::StringVersion.compare(RUBY_VERSION, :<=, "1.8")
-      include UniqBy
-
-      def uniq_by!(&b)
-        replace uniq_by(&b)
-      end
-    else
-      require 'tins/deprecate'
-      extend Tins::Deprecate
-
-      deprecate method:
-        alias_method(:uniq_by!, :uniq!),
-        new_method: :uniq!
-    end
-  end
-end

data/tests/count_by_test.rb

@@ -1,17 +0,0 @@
-require 'test_helper'
-require 'tins/xt'
-
-module Tins
-  class CountByTest < Test::Unit::TestCase
-
-    def test_count_by
-      assert_equal 0, [].count_by { |x| x % 2 == 0 }
-      assert_equal 0, [ 1 ].count_by { |x| x % 2 == 0 }
-      assert_equal 1, [ 1 ].count_by { |x| x % 2 == 1 }
-      assert_equal 1, [ 1, 2 ].count_by { |x| x % 2 == 0 }
-      assert_equal 1, [ 1, 2 ].count_by { |x| x % 2 == 1 }
-      assert_equal 2, [ 1, 2, 3, 4, 5 ].count_by { |x| x % 2 == 0 }
-      assert_equal 3, [ 1, 2, 3, 4, 5 ].count_by { |x| x % 2 == 1 }
-    end
-  end
-end

data/tests/deep_const_get_test.rb

@@ -1,37 +0,0 @@
-require 'test_helper'
-require 'tins/xt/deep_const_get'
-
-module Tins
-  class DeepConstGetTest < Test::Unit::TestCase
-    module A
-      module B
-      end
-    end
-
-    module C
-      module NotB
-      end
-
-      def self.const_missing(c)
-        NotB
-      end
-    end
-
-    def test_deep_const_get_with_start_module
-      assert_raise(ArgumentError) { deep_const_get '::B', A }
-      assert_equal A::B, deep_const_get('B', A)
-    end
-
-    def test_deep_const_get_without_start_module
-      assert_equal Tins::DeepConstGetTest::A::B, deep_const_get('::Tins::DeepConstGetTest::A::B')
-      assert_equal Tins::DeepConstGetTest::A::B, deep_const_get('Tins::DeepConstGetTest::A::B')
-      assert_equal Array, deep_const_get('::Array')
-      assert_equal Array, deep_const_get('Array')
-    end
-
-    def test_deep_const_get_with_const_missing
-      assert_raise(ArgumentError) { deep_const_get '::Tins::DeepConstGetTest::A::NIXDA' }
-      assert_equal Tins::DeepConstGetTest::C::NotB, deep_const_get('::Tins::DeepConstGetTest::C::B')
-    end
-  end
-end

data/tests/uniq_by_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-require 'tins/xt'
-
-module Tins
-  class UniqByTest < Test::Unit::TestCase
-
-    unless defined?(Point)
-      class Point < Struct.new :x, :y
-      end
-    end
-
-    def test_uniq_by
-      assert_equal [ 1, 2, 3 ], [ 1, 2, 2, 3 ].uniq_by.sort
-      a = [ 1, 2, 2, 3 ]; a.uniq_by!
-      assert_equal [ 1, 2, 3 ], a.sort
-      p1 = Point.new 1, 2
-      p2 = Point.new 2, 2
-      p3 = Point.new 2, 2
-      p4 = Point.new 3, 3
-      a = [ p1, p2, p3, p4 ]
-      a_uniq = a.uniq_by { |p| p.y }
-      assert_equal 2, a_uniq.size
-      assert a_uniq.include?(p4)
-      assert [ p1, p2, p3 ].any? { |p| a_uniq.include? p }
-      a.uniq_by! { |p| p.y }
-      assert_equal 2, a.size
-      assert a.include?(p4)
-      assert [ p1, p2, p3 ].any? { |p| a.include? p }
-    end
-  end
-end