to_wa 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff02d9d70a9c571bba011ff3f651e559498cd6cd
-  data.tar.gz: 92bba9fd29b6adfd9035a16e512729bc54b6b092
+  metadata.gz: 64fb0e5b6b7555f477aad99eeedfe5d18d083eda
+  data.tar.gz: a0647318b3e575773c68193c4c747a67280509fe
 SHA512:
-  metadata.gz: 75b7af23c3c6cf5cfb46ebd4533c9bb9bec6705e7b480b059071125bb2993fc3e7b017f1a25e5d2446ce52dd74b5916fe4bbabd3444b7f5e0eb2d2e9b17473ad
-  data.tar.gz: bea440ef0ff39602c6f265b8046ef359323f876b6b6b12a76beaabe5b8ae055953ca6b7306eca6cb27aa795845a60d6eae404de339bab05979a65e7f70fe8422
+  metadata.gz: a1648c143778d42f291f87aa8b2d56b5f9e8001a9fa564ad6e41422c2d15e4643ef8971398d68571e5234874ce9c817e2f25b2b84aa8ce26c9d01b1a93cabd26
+  data.tar.gz: d02ec68c2568671103d721ce2fb291660b569ea4fde6bd71f11d08d6495e063811543b0a3275b7e4a339bdef57f95f785606163820796373121258d969a995f1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    to_wa (0.2.0)
+    to_wa (0.3.0)
       activerecord
 
 GEM

data/README.md

@@ -7,16 +7,38 @@
 # Installation
 
 ```ruby
-gem 'ToWa'
+gem 'to_wa'
 ```
 
 ```console
 bundle install
 ```
 
+## Use all columns and operators
+
+```ruby
+class TestRecord < ActiveRecord::Base
+  extend ToWa
+
+  permit_all_to_wa_operators!
+  permit_all_to_wa_columns!
+
+  # read section: Use specific table columns as left and right
+  permit_all_to_wa_specified_columns!
+end
+```
+
+## Or specify columns and operators
+
 ```ruby
 class TestRecord < ActiveRecord::Base
   extend ToWa
+
+  permit_to_wa_columns :a, :b, :x
+  permit_to_wa_operators :eq, :ne
+
+  # read section: Use specific table columns as left and right
+  permit_to_wa_specified_columns foo_records: [:a], bar_records: [:b]
 end
 ```
 
@@ -96,7 +118,6 @@ and|and|
 or|or|
 not|not|It must receive Array that includes only one data. `{ "not": [{ "name": "ToWa" }] }`
 
-
 # Usage
 
 (Ofcourse, `ActiveRecord::Relation` will be provided after `to_wa` without `to_sql`.)
@@ -135,6 +156,28 @@ TestRecord.to_wa(
 #=> "SELECT `test_records`.* FROM `test_records` WHERE ((`test_records`.`name` = 'ToWa' OR `test_records`.`name` = 'to_wa') AND `test_records`.`gender` = 'male')"
 ```
 
+## Use specific table columns as left and right
+
+```ruby
+class TestRecord < ActiveRecord::Base
+  extend ToWa
+  has_many :users
+end
+
+class User < ActiveRecord::Base
+end
+
+TestRecord.left_outer_joins(:users).to_wa(
+  {
+    '>': [
+      { 'col': ['users', 'left_arm_length'] },
+      { 'col': ['users', 'right_arm_length'] }
+    ]
+  }
+).to_sql
+#=> "SELECT `test_records`.* FROM `test_records` LEFT OUTER JOIN `users` ON `users`.`test_record_id` = `test_records`.`id` WHERE (`users`.`left_arm_length` > `users`.`right_arm_length`)"
+```
+
 ## Working with other query
 
 ```ruby
@@ -153,4 +196,4 @@ a.to_sql
 #=> "`test_records`.`name` = 'ToWa'"
 TestRecord.where(a).to_sql
 #=> "SELECT `test_records`.* FROM `test_records` WHERE `test_records`.`name` = 'ToWa'"
-```
+```

data/db/migration.rb

@@ -1,6 +1,12 @@
 class ToWaTestMigration < ActiveRecord::Migration[5.1]
   class << self
     def up
+      create_table(:users) do |t|
+        t.integer :left_arm_length
+        t.integer :right_arm_length
+        t.references :test_record
+      end
+
       create_table(:test_records) do |t|
         t.string :a
         t.string :b
@@ -8,15 +14,23 @@ class ToWaTestMigration < ActiveRecord::Migration[5.1]
         t.integer :x
         t.integer :y
         t.integer :z
+        t.string :denied_column
       end
     rescue
       nil
     end
 
     def down
-      drop_table(:test_records)
-    rescue
-      nil
+      begin
+        drop_table(:users)
+      rescue
+        nil
+      end
+      begin
+        drop_table(:test_records)
+      rescue
+        nil
+      end
     end
   end
 end

data/db/preparation.rb

@@ -11,4 +11,5 @@ rescue ActiveRecord::StatementInvalid => e
 end
 
 ActiveRecord::Base.establish_connection(ToWaTestConfiguration::FULL_SET)
+ToWaTestMigration.down
 ToWaTestMigration.up

data/lib/to_wa.rb

@@ -1,21 +1,29 @@
 require 'to_wa/version'
-require 'active_record'
+require 'to_wa/exceptions'
+require 'to_wa/configuration'
+require 'to_wa/easy_hash_access'
+require 'to_wa/builder'
+require 'to_wa/core'
 
 module ToWa
-  require 'to_wa/builder'
-  require 'to_wa/core'
+  include ::ToWa::Configuration
 
-  def to_wa(o)
-    ::ToWa::Core.to_wa(self, o)
-  end
-
-  def to_wa_raw(arel_table, o)
-    ToWa(arel_table, o)
+  def to_wa(ex)
+    where(
+      ::ToWa::Builder.new(
+        arel_table: arel_table,
+        restricted: true,
+        permitted_columns: permitted_to_wa_columns,
+        permitted_operators: permitted_to_wa_operators,
+        permitted_specified_columns: permitted_to_wa_specified_columns,
+        ex: ex,
+      ).execute!,
+    )
   end
 end
 
 module Kernel
-  def ToWa(arel_table, o) # rubocop:disable Naming/MethodName
-    ::ToWa::Core.to_wa_raw(arel_table, o)
+  def ToWa(arel_table, ex) # rubocop:disable Naming/MethodName
+    ::ToWa::Builder.new(restricted: false, arel_table: arel_table, ex: ex).execute!
   end
 end

data/lib/to_wa/builder.rb

@@ -1,56 +1,134 @@
 require 'json'
+require 'active_record'
 
+# rubocop:disable Metrics/ClassLength
 module ToWa
-  module Builder
+  class Builder
+    using ::ToWa::EasyHashAccess
     include ActiveRecord::Sanitization
 
-    def to_wa(ar, ex)
-      ar.where(to_wa_raw(ar.arel_table, ex))
+    # rubocop:disable Metrics/ParameterLists
+    def initialize(
+      restricted:,
+      ex:,
+      arel_table:,
+      permitted_columns: Set.new,
+      permitted_operators: Set.new,
+      permitted_specified_columns: {}
+    )
+      @restricted = restricted
+      @arel_table = arel_table
+      @initial_ex = ex.is_a?(String) ? JSON.parse(ex) : ex
+      @permitted_columns = permitted_columns
+      @permitted_operators = permitted_operators
+      @permitted_specified_columns = permitted_specified_columns
     end
+    # rubocop:enable Metrics/ParameterLists
 
-    def to_wa_raw(arel_table = nil, ex)
-      decide(arel_table, ex.is_a?(String) ? JSON.parse(ex) : ex)
+    def self.like(v)
+      sanitize_sql_like(v)
+    end
+
+    def execute!
+      decide(@initial_ex)
+    end
+
+    private
+
+    def restricted?
+      @restricted
+    end
+
+    def permitted_columns?(v)
+      return true unless restricted?
+      @permitted_columns.include?(v)
+    end
+
+    def permitted_operators?(v)
+      return true unless restricted?
+      @permitted_operators.include?(v)
     end
 
-    def decide(arel_table, ex)
-      op = ::ToWa::Core::OPERATORS[ex.keys.first.to_s]
-      values = ex.values.first
+    def decide(ex)
+      op = detect_op!(ex.k)
+      lr_or_exes = ex.v
 
       case op
       when 'not'
-        decide(arel_table, values.first).not
+        decide(lr_or_exes.first).not
       when 'and', 'or'
-        add_logic(arel_table, op, values)
+        add_logic(op, lr_or_exes)
+      when 'between'
+        between_to_gteq_and_lteq(*lr_or_exes)
       else
-        add_comparison(arel_table, op, *values)
+        add_comparison(op, *lr_or_exes)
       end
     end
 
-    def add_comparison(arel_table, op, table, value)
-      normalized =
-        case op
-        when 'between'
-          value.first..value.second
-        when 'matches'
-          "%#{ToWa::Builder.like(value)}%"
-        else
-          value
-        end
+    def detect_op!(op)
+      sop = op.to_s
+      raise ::ToWa::DeniedOperator, sop unless permitted_operators?(sop)
+      ::ToWa::Core::OPERATORS[sop]
+    end
 
-      arel_table[table].send(op, normalized)
+    def add_comparison(op, left, right)
+      normalize_value(left) { normalize_left_table(left) }.send(op, normalize_right(op, right))
     end
 
-    def add_logic(arel_table, op, exes)
-      logics =
-        exes.inject(nil) do |a, ex|
-          a.nil? ? decide(arel_table, ex) : a.send(op, decide(arel_table, ex))
-        end
+    def between_to_gteq_and_lteq(left, right)
+      decide({
+        'and' => [
+          { '>=' => [left, right.first] },
+          { '<=' => [left, right.second] },
+        ],
+      })
+    end
 
-      (exes.size == 1) ? logics : Arel::Nodes::Grouping.new(logics)
+    def normalize_left_table(left)
+      raise ::ToWa::DeniedColumn, left unless permitted_columns?(left)
+      @arel_table[left]
     end
 
-    def self.like(v)
-      sanitize_sql_like(v)
+    def normalize_value(o, &block)
+      case
+      when o.is_a?(Hash) && o.k.to_s == 'col'
+        specify_columns(*o.v.map(&:to_s))
+      when block_given?
+        block&.call
+      else
+        o
+      end
+    end
+
+    def all_specified_columns_allowed?
+      @permitted_specified_columns == ::ToWa::AllSpecifiedColumnsAllowance
+    end
+
+    def permitted_specified_columns?(table, column)
+      return true unless restricted?
+      return true if all_specified_columns_allowed?
+
+      @permitted_specified_columns[table]&.include?(column)
+    end
+
+    def specify_columns(table, column)
+      raise ::ToWa::DeniedColumn, [table, column] unless permitted_specified_columns?(table, column)
+
+      Arel::Table.new(table)[column]
+    end
+
+    def normalize_right(op, right)
+      if op == 'matches'
+        "%#{ToWa::Builder.like(right)}%"
+      else
+        normalize_value(right)
+      end
+    end
+
+    def add_logic(op, exes)
+      logic = exes[1..-1].inject(decide(exes.first)) { |a, ex| a.send(op, decide(ex)) }
+      Arel::Nodes::Grouping.new(logic)
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

data/lib/to_wa/configuration.rb

@@ -0,0 +1,45 @@
+require 'json'
+
+module ToWa
+  module Configuration
+    def permit_to_wa_columns(*columns)
+      @permitted_to_wa_columns = Set.new(columns.map(&:to_s))
+    end
+
+    def permit_all_to_wa_columns!
+      @permitted_to_wa_columns = Set.new(self.column_names)
+    end
+
+    def permit_to_wa_specified_columns(hash)
+      @permitted_to_wa_specified_columns =
+        JSON.parse(hash.to_json).inject({}) { |a, (k, v)| a.merge!(k => Set.new(Array(v))) }
+    end
+
+    def permit_all_to_wa_specified_columns!
+      @permitted_to_wa_specified_columns = ::ToWa::AllSpecifiedColumnsAllowance
+    end
+
+    def permit_to_wa_operators(*operators)
+      @permitted_to_wa_operators = Set.new(operators.map(&:to_s))
+    end
+
+    def permit_all_to_wa_operators!
+      @permitted_to_wa_operators = ToWa::Core::OPERATORS
+    end
+
+    def permitted_to_wa_columns
+      @permitted_to_wa_columns ||= Set.new
+    end
+
+    def permitted_to_wa_specified_columns
+      @permitted_to_wa_specified_columns ||= {}
+    end
+
+    def permitted_to_wa_operators
+      @permitted_to_wa_operators ||= Set.new
+    end
+  end
+
+  module AllSpecifiedColumnsAllowance
+  end
+end

data/lib/to_wa/core.rb

@@ -1,7 +1,5 @@
 module ToWa
   module Core
-    extend ::ToWa::Builder
-
     COMPARISON = {
       '==' => 'eq',
       '=' => 'eq',

data/lib/to_wa/easy_hash_access.rb

@@ -0,0 +1,13 @@
+module ToWa
+  module EasyHashAccess
+    refine Hash do
+      def k
+        keys.first
+      end
+
+      def v
+        values.first
+      end
+    end
+  end
+end

data/lib/to_wa/exceptions.rb

@@ -0,0 +1,7 @@
+module ToWa
+  class DeniedOperator < StandardError
+  end
+
+  class DeniedColumn < StandardError
+  end
+end

data/lib/to_wa/version.rb

@@ -1,3 +1,3 @@
 module ToWa
-  VERSION = '0.2.0'.freeze
+  VERSION = '0.3.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: to_wa
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - mmmpa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-20 00:00:00.000000000 Z
+date: 2018-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -131,7 +131,10 @@ files:
 - db/preparation.rb
 - lib/to_wa.rb
 - lib/to_wa/builder.rb
+- lib/to_wa/configuration.rb
 - lib/to_wa/core.rb
+- lib/to_wa/easy_hash_access.rb
+- lib/to_wa/exceptions.rb
 - lib/to_wa/version.rb
 - to_wa.gemspec
 homepage: http://mmmpa.net