sqlite3_extend_function 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b370727ad3e7fe4e4dbce17de3372fb15fff6c2193f2400563c1a7a1e9e6fc88
-  data.tar.gz: d66b7180e476b6154ff201b82424df92f0e28572643e7de869ddd842a9707159
+  metadata.gz: 80bfa77fec9b09e2cf91f422d457b75f4d4a29f477a34b677ce33252b8a4c02a
+  data.tar.gz: e4bd09974e3c5353c622a3adbdf8b6c3f03040ff1128db0e495569bb769e6a29
 SHA512:
-  metadata.gz: b52dc19acdd7720c481acdc73ba8390aaad68f79181f0d9ce4f0fff87bd6c4b512e01bd2faa7141461b6efc4b9909a3b306ff0544c3b233c8b833c5183750940
-  data.tar.gz: d2f10a203913bbdcf6bf7d1c85e48b0be609cf158ae08209dbe6016561e28653350092f2d7b487a486c05680133b52c847b60073a5b3dd89550518ec26cf633c
+  metadata.gz: 01a2867fe5fc9ae7b005eec2ab1310938338fb323fb2336f2f11155a3af60cb79b3ef5215e85e2303c478d31e3b15416a2bba0d5fe51cc9bebe87c0593d718d1
+  data.tar.gz: ffd1a7a02b6db7e1e4fede1c2dc33676d496af8e5b278a45f1eaea5758edd240117bfbec9b35f65721f340366df366e43bc42472417545c04f95946549c5ce8e

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor
+.DS_Store
+Gemfile.lock
+.rspec
+
+# rspec failure tracking
+.rspec_status

data/.rubocop.yml

@@ -0,0 +1,36 @@
+AllCops:
+  TargetRubyVersion: 2.4
+  NewCops: enable
+Lint/DuplicateBranch:
+  Enabled: true
+Lint/DuplicateRegexpCharacterClassElement:
+  Enabled: true
+Lint/EmptyBlock:
+  Enabled: true
+Lint/EmptyClass:
+  Enabled: true
+Lint/NoReturnInBeginEndBlocks:
+  Enabled: true
+Lint/ToEnumArguments:
+  Enabled: true
+Lint/UnmodifiedReduceAccumulator:
+  Enabled: true
+Naming/MethodParameterName:
+  Enabled: false
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*
+Style/ArgumentsForwarding:
+  Enabled: true
+Style/CollectionCompact:
+  Enabled: true
+Style/DocumentDynamicEvalDefinition:
+  Enabled: true
+Style/NegatedIfElseCondition:
+  Enabled: true
+Style/NilLambda:
+  Enabled: true
+Style/RedundantArgument:
+  Enabled: true
+Style/SwapValues:
+  Enabled: true

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# CHANGELOG
+
+## 0.3.0 / 2020-12-20
+### Modified
+- Added specification to add extend function
+- Remove SQLite3 from dependency
+- Abolished automatic include of extend function
+- Ruby version changed to 2.4 or higher
+
+## 0.2.0 / 2019-12-05
+### Modified
+- Remove ActiveRecord from dependency
+- Add function
+
+## 0.1.0 / 2019-12-03
+### Modified
+- Create ceil and floor functions

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in qlite3_extend_function.gemspec
+gemspec
+
+gem 'rake', '~> 13.0'
+gem 'rspec', '~> 3.10'
+gem 'sqlite3', '~> 1.4'

data/README.md

@@ -1,6 +1,6 @@
 # SQLite3ExtendFunction
 
-Add some user-defined function to SQL when using SQLie3.
+Add some user-defined function to SQL when using SQLite3.
 
 ## Functions
 
@@ -47,8 +47,9 @@ The following PostgreSQL functions are supported.
 
 See [PostgreSQL Document](https://www.postgresql.org/docs/12/functions.html)
 
-```
+```ruby
 # check
+SQLite3::Database.include(SQLite3ExtendFunction)
 db = SQLite3::Database.new(':memory:')
 
 db.execute("select ceil(0.1)")[0][0]
@@ -62,7 +63,7 @@ db.execute("select floor(1.1)")[0][0]
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'sqlite3_extend_function', '~> 0.2'
+gem 'sqlite3_extend_function', '~> 0.3'
 
 # master branch
 gem 'sqlite3_extend_function',
@@ -75,5 +76,33 @@ And then execute:
 $ bundle
 ```
 
+## Enable extend functions
+
+```ruby
+SQLite3::Database.include(SQLite3ExtendFunction)
+```
+
+## Add extend function
+
+Extend function can be added by defining modules such as:
+
+```ruby
+module SQLite3ExtendFunction
+  module Functions
+    module FunctionName
+      class << self
+        def call(arg1)
+          # ...
+        rescue StandardError
+          raise SQLite3::SQLException, 'error message'
+        end
+      end
+    end
+  end
+end
+```
+
+Extend function name is "FunctionName" as the snake case.
+
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'sqlite3_extend_function'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sqlite3_extend_function.rb

@@ -1,27 +1,25 @@
 # frozen_string_literal: true
 
-require 'sqlite3'
+require 'bigdecimal'
+require 'base64'
+require 'digest/md5'
 require 'sqlite3_extend_function/version'
 require 'sqlite3_extend_function/function'
+require 'sqlite3_extend_function/functions'
 
 # SQLite3ExtendFunction
 module SQLite3ExtendFunction
+  # @param [Class] base
+  # @return [void]
   def self.included(base)
     base.class_eval do
       original_method = instance_method(:initialize)
       define_method(:initialize) do |*args, &block|
         result = original_method.bind(self).call(*args)
-        SQLite3ExtendFunction::Function.singleton_methods.each do |func|
-          lmd = Function.send(func)
-          create_function(func.to_s, (lmd.parameters.size - 1), &lmd)
-        end
-        # frozen_string_literal: true
-        # SQLite3ExtendFunction
+        Functions.each { |func| create_function(func.name, func.arity, &func.to_proc) }
         block&.call(self)
         result
       end
     end
   end
 end
-
-SQLite3::Database.include(SQLite3ExtendFunction)

data/lib/sqlite3_extend_function/function.rb

@@ -1,565 +1,30 @@
 # frozen_string_literal: true
 
-require 'bigdecimal'
-require 'base64'
-require 'digest/md5'
 module SQLite3ExtendFunction
   # SQLite3ExtendFunction::Function
-  module Function
-    class << self
-      # @return [Proc]
-      def ceil
-        lambda do |func, dp|
-          return if dp.nil?
-
-          begin
-            func.result = Kernel.Float(dp).ceil.to_i
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: \"#{dp}\""
-          end
-        end
-      end
-
-      # @return [Proc]
-      def floor
-        lambda do |func, dp|
-          return if dp.nil?
-
-          begin
-            func.result = Kernel.Float(dp).floor.to_i
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: \"#{dp}\""
-          end
-        end
-      end
-
-      # cube root
-      # @return [Proc]
-      def cbrt
-        lambda do |func, dp|
-          return if dp.nil?
-
-          begin
-            result = Math.cbrt(Kernel.Float(dp))
-            func.result = result.to_i == result ? result.to_i : result
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: \"#{dp}\""
-          end
-        end
-      end
-
-      # radians to degrees
-      # @return [Proc]
-      def degrees
-        lambda do |func, dp|
-          return if dp.nil?
-
-          begin
-            func.result = Kernel.Float(dp) * 180 / Math::PI
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: \"#{dp}\""
-          end
-        end
-      end
-
-      # integer quotient of y/x
-      # @return [Proc]
-      def div
-        lambda do |func, y, x|
-          return if y.nil? || x.nil?
-
-          begin
-            func.result = Kernel.Float(y).div(Kernel.Float(x))
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  'invalid input syntax for type numeric'
-          end
-        end
-      end
-
-      # exponential
-      # @return [Proc]
-      def exp
-        lambda do |func, dp|
-          return if dp.nil?
-
-          begin
-            result = Math.exp(Kernel.Float(dp))
-            func.result = result.to_i == result ? result.to_i : result
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: \"#{dp}\""
-          end
-        end
-      end
-
-      # natural logarithm
-      # @return [Proc]
-      def ln
-        lambda do |func, dp|
-          return if dp.nil?
-
-          begin
-            result = Math.log(Kernel.Float(dp))
-            func.result = result.to_i == result ? result.to_i : result
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  'cannot take logarithm of a negative number'
-          end
-        end
-      end
-
-      # base 10 logarithm
-      # @return [Proc]
-      def log
-        lambda do |func, y, x = nil|
-          if x.nil?
-            return if y.nil?
-
-            result = Math.log10(Kernel.Float(y))
-            func.result = result.to_i == result ? result.to_i : result
-          else
-            return if y.nil? || x.nil?
-
-            func.result = Math.log(x, y)
-          end
-        rescue ArgumentError
-          raise SQLite3::SQLException,
-                'invalid input syntax for type numeric'
-        end
-      end
-
-      # remainder of y/x
-      # @return [Proc]
-      def mod
-        lambda do |func, y, x|
-          func.result = Kernel.Float(y).modulo(Kernel.Float(x)).to_i
-        rescue ArgumentError
-          raise SQLite3::SQLException,
-                'Could not choose a best candidate function. You might need to add explicit type casts.'
-        end
-      end
-
-      # "π" constant
-      # @return [Proc]
-      def pi
-        lambda do |func|
-          func.result = Math::PI
-        end
-      end
-
-      # a raised to the power of b
-      # @return [Proc]
-      def power
-        lambda do |func, a, b|
-          return if a.nil? || b.nil?
-
-          begin
-            result = Kernel.Float(a)**Kernel.Float(b)
-            func.result = result.to_i == result ? result.to_i : result
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  'invalid input syntax for type double precision'
-          end
-        end
-      end
-
-      # degrees to radians
-      # @return [Proc]
-      def radians
-        lambda do |func, dp|
-          return if dp.nil?
-
-          begin
-            result = Kernel.Float(dp) * Math::PI / 180
-            func.result = result.to_i == result ? result.to_i : result
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: \"#{dp}\""
-          end
-        end
-      end
-
-      # sign of the argument (-1, 0, +1)
-      # @return [Proc]
-      def sign
-        lambda do |func, dp|
-          return if dp.nil?
-
-          begin
-            value = Kernel.Float(dp)
-            func.result = if value.zero?
-                            0
-                          elsif value.positive?
-                            1
-                          else
-                            -1
-                          end
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: \"#{dp}\""
-          end
-        end
-      end
-
-      # square root
-      # @return [Proc]
-      def sqrt
-        lambda do |func, dp|
-          return if dp.nil?
-
-          begin
-            result = Math.sqrt(Kernel.Float(dp))
-            func.result = result.to_i == result ? result.to_i : result
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: \"#{dp}\""
-          end
-        end
-      end
-
-      # truncate toward zero
-      # @return [Proc]
-      def trunc
-        lambda do |func, dp, s = 0|
-          return if dp.nil?
-
-          begin
-            ss = BigDecimal(Kernel.Float(s).to_s)
-            dec = if ss.zero?
-                    BigDecimal('1.0')
-                  else
-                    BigDecimal((1.0 / (10**ss).to_f).to_s)
-                  end
-            result = (BigDecimal(Kernel.Float(dp).to_s) / dec).to_i * dec
-            func.result = result.to_i == result ? result.to_i : result.to_f
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  'invalid input syntax for type double precision'
-          end
-        end
-      end
-
-      # return the bucket number to which operand would be assigned input
-      # a histogram having count equal-width buckets spanning the range b1 to b2;
-      # returns 0 or count+1 for an input outside the range
-      # @return [Proc]
-      def width_bucket
-        lambda do |func, operand, b1, b2, count|
-          begin
-            operand = Kernel.Float(operand)
-            b1 = Kernel.Float(b1)
-            b2 = Kernel.Float(b2)
-            count = Kernel.Float(count)
-
-            raise ArgumentError unless count.positive?
-            result = (operand / ((b2 - b1) / count)).ceil
-            result = count + 1 if result > count
-            result = 0 if result.negative?
-            func.result = result.to_i
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  'ArgumentError'
-          end
-        end
-      end
-
-      # @return [Proc]
-      def acos
-        lambda do |func, x|
-          begin
-            func.result = Math.acos(Kernel.Float(x))
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: #{x}"
-          end
-        end
-      end
-
-      # @return [Proc]
-      def asin
-        lambda do |func, x|
-          begin
-            func.result = Math.asin(Kernel.Float(x))
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: #{x}"
-          end
-        end
-      end
-
-      # @return [Proc]
-      def atan
-        lambda do |func, x|
-          begin
-            func.result = Math.atan(Kernel.Float(x))
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: #{x}"
-          end
-        end
-      end
-
-      # @return [Proc]
-      def atan2
-        lambda do |func, y, x|
-          begin
-            func.result = Math.atan2(Kernel.Float(y), Kernel.Float(x))
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision"
-          end
-        end
-      end
-
-      # @return [Proc]
-      def cos
-        lambda do |func, x|
-          begin
-            func.result = Math.cos(Kernel.Float(x))
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: #{x}"
-          end
-        end
-      end
-
-      # @return [Proc]
-      def cot
-        lambda do |func, x|
-          begin
-            func.result = 1 / Math.tan(Kernel.Float(x))
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: #{x}"
-          end
-        end
-      end
-
-      # @return [Proc]
-      def sin
-        lambda do |func, x|
-          begin
-            func.result = Math.sin(Kernel.Float(x))
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: #{x}"
-          end
-        end
-      end
-
-      # @return [Proc]
-      def tan
-        lambda do |func, x|
-          begin
-            func.result = Math.tan(Kernel.Float(x))
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                  "invalid input syntax for type double precision: #{x}"
-          end
-        end
-      end
-
-      # Number of bits in string
-      # @return [Proc]
-      def bit_length
-        lambda do |func, str|
-          begin
-            func.result = str.bytesize * 8
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
-
-      # Number of characters in string
-      # @return [Proc]
-      def char_length
-        lambda do |func, str|
-          begin
-            func.result = str.length
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
-
-      # octet_length
-      # @return [Proc]
-      def octet_length
-        lambda do |func, str|
-          begin
-            func.result = str.bytesize
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
-
-      # @return [Proc]
-      def ascii
-        lambda do |func, str|
-          begin
-            raise ArgumentError if str.is_a? String
-
-            func.result = str.ord
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
-
-      # @return [Proc]
-      def btrim
-        lambda do |func, text, chrs = ''|
-          begin
-            func.result = text.sub(/\A[#{chrs}]*/, '').sub(/[#{chrs}]*\z/, '')
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
-
-      # @return [Proc]
-      def chr
-        lambda do |func, int|
-          begin
-            func.result = int.chr
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
-
-      # @return [Proc]
-      def concat
-        lambda do |func, *args|
-          begin
-            func.result = args.compact.join
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
-
-      # @return [Proc]
-      def concat_ws
-        lambda do |func, sep, *args|
-          begin
-            func.result = args.compact.join(sep)
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
-
-      # @return [Proc]
-      def decode
-        lambda do |func, str, format|
-          return if data.nil?
-
-          begin
-            raise ArgumentError if data.is_a? String
-
-            func.result = case format
-                          when 'base64'
-                            Base64.decode64(str)
-                          when 'hex'
-                            str.scan(/.{2}/).map(&:hex).map(&:chr).join
-                          when 'escape'
-                            raise ArgumentError
-                          else
-                            raise ArgumentError
-                          end
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
-
-      # @return [Proc]
-      def encode
-        lambda do |func, data, format|
-          return if data.nil?
-
-          begin
-            raise ArgumentError if data.is_a? String
-
-            func.result = case format
-                          when 'base64'
-                            Base64.encode64(data)
-                          when 'hex'
-                            data.unpack("C*").map { |c| c.to_s(16) }.join
-                          when 'escape'
-                            raise ArgumentError
-                          else
-                            raise ArgumentError
-                          end
-          rescue ArgumentError
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
-
-      # @return [Proc]
-      def format
-        lambda do |func, formartstr, *args|
-          func.result = formartstr % args
-        end
-      end
-
-      # @return [Proc]
-      def initcap
-        lambda do |func, str|
-          return if str.nil?
-
-          begin
-            regexp = /([a-zA-Z0-9]*|[^a-zA-Z0-9]*)/
-            func.result = str.split(regexp).map.with_index { |s, i|
-              i.odd? ? s.downcase.capitalize : s
-            }.join
-          rescue
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
+  class Function
+    # @param [Class] mod
+    # @return [void]
+    def initialize(mod)
+      @mod = mod
+    end
 
-      # @return [Proc]
-      def md5
-        lambda do |func, str|
-          return if str.nil?
+    # @return [String]
+    def name
+      @mod.name.split('::').last
+          .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .tr('-', '_').downcase
+    end
 
-          begin
-            func.result = Digest::MD5.hexdigest(str)
-          rescue
-            raise SQLite3::SQLException,
-                 "No function matches the given name and argument types. You might need to add explicit type casts."
-          end
-        end
-      end
+    # @return [Proc]
+    def to_proc
+      ->(func, *argv) { func.result = @mod.call(*argv) }
+    end
 
-      # Current date and time (start of current transaction)
-      # @return [Proc]
-      def now
-        lambda do |func|
-          func.result = Time.now.strftime('%Y-%m-%d %H:%M:%S.%6N%:z')
-        end
-      end
+    # @return [Integer]
+    def arity
+      @mod.method(:call).parameters.size
     end
   end
 end