terrazine 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f1a24d3310a23b60eb51584c7fdcec61a03c2b58
+  data.tar.gz: 3be3456371d57ae8b67918d5d3b09a6447ff9194
+SHA512:
+  metadata.gz: c5a940bf57c92d76934211d9f6bbcca8ec9ed0bd8e42f6f788feb817309c6dcf3edb1d3f567718d1c847c051efc992a85e89ff985b86969d2ae3a114ab80a58a
+  data.tar.gz: 92462094a13958703b45b35305b5cc1107db055119a0847cfd2a5a34bf59d63525be94d3309e4972985e24ad5926ab2b29addb916fd1e7732eebf2f7b457abed

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+terrazine*.gem
+
+# rspec failure tracking
+.rspec_status

data/.rubocop.yml

@@ -0,0 +1,10 @@
+#  This check makes sense only in Ruby 1.9, since in 2.0+ utf-8 is the default source file encoding.
+Style/Encoding:
+  Enabled: false
+
+# Commonly used screens these days easily fit more than 80 characters.
+Metrics/LineLength:
+  Max: 100
+
+AllCops:
+  TargetRubyVersion: '2.3.1'

data/Gemfile

@@ -0,0 +1 @@
+gem 'pg-hstore', '1.2.0'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Aeonax
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,182 @@
+# Terrazin
+
+## Idea
+Simple and comfortable, as possible, data structures parser in to SQL.  
+
+#### Data
+Describing sql with data structures like [honeysql](https://github.com/jkk/honeysql) or [ql](https://github.com/niquola/ql) in clojure.  
+
+#### Constructor
+Construct data structures inside Constructor instance.
+
+#### Result
+Get result and access any returned data rails like syntax.
+
+#### Realization
+This is my first gem and first close meeting with OOP... I would appreciate any help =)
+And sorry for my English =(
+
+## Detailed description
+
+### Usage
+Describe whole data structure, or create `Constructor` instance and combine parts of data by it instance methods. Then send result to `Terrazine.send_request(structure||constructor, params = {})` and it will return you `Terrazine::Result` instance. (description will be soon)
+
+### Constructor
+You can create Constructor instance by calling `Terrazine.new_constructor`. It optional accepts data structure.  
+
+```ruby
+constructor = Terrazine.new_constructor
+constructor_2 = Terrazine.new_constructor from: :calls
+```
+#### Instance methods
+Instance methods write or combine data inside constructor instance.
+Not finished methods - just rewrites structure without combination with existing data.  
+- [ ] with
+- [x] select/distinct_select
+- [ ] from
+- [ ] join
+- [x] where
+- [x] limit
+- [x] paginate
+- [x] merge - just merging instance structure with argument
+- [x] build_sql
+
+### Data Structures
+
+#### Select
+Accepts 
+- `String` || `Symbol`
+- `Hash` represents column alias - 'AS' (if key begins from `_`) OR table alias that will join to the values table prefix OR another data structure(present keyword `:select`).
+- Another `Constructor` or `Hash` representing data structure
+- `Array` can contain all of the above structures OR in case of first symbol/string begins from `_` it will represent SQL function  
+```ruby
+constructor.select "name, email"
+constructor.select :birthdate
+constructor.select m: [:common_rating, :work_rating, { _master_id: :id }]
+constructor.select { _missed_calls_count: { select: [:_count, [:_nullif, :connected, :true]],
+                                           from: [:calls, :c],
+                                           where: ['c.client_id = u.id',
+                                                   ['direction = ?', 0]]} }
+constructor.structure
+# => { select: ['name, email', :birthdate,
+#               { m: [:common_rating, :work_rating, { _master_id: :id }] },
+#               { _missed_calls_count: { select: [:_count, [:_nullif, :connected, :true]],
+#                                        from: [:calls, :c],
+#                                        where: ['c.client_id = u.id',
+#                                                ['direction = ?', 0]]} }] }
+
+constructor.build_sql
+# => ['SELECT name, email, birthdate, m.common_rating, m.work_rating, m.id AS master_id,
+#             (SELECT COUNT(NULLIF(connected, TRUE))
+#              FROM calls c
+#              WHERE c.client_id = u.id AND direction = $1) AS missed_calls_count',
+#     0]
+```
+
+#### From
+Accepts
+- `String` || `Symbol`
+- `Array` can contains table_name and table_alias OR `VALUES` OR both  
+```ruby
+from 'table_name table_alias' || :table_name
+from [:table_name, :table_alias]
+from [[:table_name, :table_alias], [:_values, [1, 2], :values_name, [*values_column_names]]]
+from [:mrgl, [:_values, [1, 2], :rgl, [:zgl, :gl]]]
+```
+I do not like the `from` syntax, but how it can be made more convenient...?
+
+#### Join
+Accpets
+- `String`
+- `Array`:
+First element same as `from` first element - table name or `Array` of table_name and table_alias, then `Hash` with keys:
+  - on - conditions(description will be bellow)
+  - options - optional contains `Symbol` or `String` of join type... rename to type?  
+
+`Array` can be nested  
+```ruby
+join 'users u ON u.id = m.user_id'
+join ['users u ON u.id = m.user_id',
+      'skills s ON u.id = s.user_id']
+join [[:user, :u], { on: 'rgl = 123' }]
+join [[[:user, :u], { option: :full, on: [:or, 'mrgl = 2', 'rgl = 22'] }],
+      [:master, { on: ['z = 12', 'mrgl = 12'] }]]
+```
+
+#### Conditions
+Current conditions implementation is sux... -_- Soon i'll change it.  
+Now it accepts `String` or `Array`.  
+First element of array is `Symbol` representation of join condition - `:or || :and` or by default `:and`.  
+```ruby
+conditions 'mrgl = 12'
+conditions ['z = 12', 'mrgl = 12']
+conditions ['NOT z = 13', [:or, 'mrgl = 2', 'rgl = 22']]
+conditions [:or, ['NOT z = 13', [:or, 'mrgl = 2', 'rgl = 22']],
+                 [:or, 'rgl = 12', 'zgl = lol']]
+conditions [['NOT z = 13',
+            [:or, 'mrgl = 2', 'rgl = 22']],
+            [:or, 'rgl = 12', 'zgl = lol']]
+# => 'NOT z = 13 AND (mrgl = 2 OR rgl = 22) AND (rgl = 12 OR zgl = lol)'
+```
+
+#### With
+```ruby
+with [:alias_name, { select: true, from: :users}]
+with [[:alias_name, { select: true, from: :users}],
+      [:alias_name_2, { select: {u: [:name, :email]},
+                        from: :rgl}]]
+```
+
+#### Union
+```ruby
+union: [{ select: true, from: [:o_list, [:_values, [1], :al, [:master]]] },
+        { select: true, from: [:co_list, [:_values, [0, :FALSE, :TRUE, 0],
+                                                    :al, [:rating, :rejected,
+                                                          :payment, :master]]] }]
+```
+
+### Result representation
+#### ::Row
+Result row - allow accessing data by field name via method - `row.name # => "mrgl"` or get hash representation with `row.to_h`
+Contains
+- `values`
+- `pg_result` - `::Result` instance
+
+#### ::Result < ::Row
+Data can be accessed like from row - it use first row, or you can iterate rows.  
+Methods `each`, `each_with_index`, `first`, `last`, `map`, `count`, `present?` delegates to `rows`. `index` delegates to `fields`.  
+For data representation as `Hash` or `Array` exists method `present`  
+After initialize `PG::Result` cleared  
+##### Contains
+- `rows` - Array of `::Row`
+- `fields` - Array of column/alias names of returned data
+- `options`
+##### Options
+- `:types` - hash representing which column require additional parsing and which type
+- `:presenter_options`
+
+#### ::Presenter
+Used in `result.present(options = {})` - it represents data as `Hash` or `Array`. options are merged with `result.options[:presenter_options]`
+Data will be presented as `Array` if `rows > 1` or `options[:array]` present.
+##### Available options
+- `array` - if querry returns only one row, but on client you await for array of data.
+- `structure` - `Hash` with field as key and value as modifier. Modifier will rewrite field value in result. Modifier acts:
+  - `Proc` - it will call proc with row as argument, and! then pass it to modifier_presentation again
+  - `::Result` - it will call `modifier.present`
+  - any else will be returned without changes
+
+## TODO:
+- [ ] Parse data like arrays, booleans, nil to SQL
+- [ ] Relocate functions builder in to class, finally I found how it can be done nice=))
+- [ ] meditate about structure supporting another databases(now supports only postgress)
+- [ ] should I bother with extra spaces?
+
+### Tests
+- [ ] Constructor + Builder
+- [ ] Result
+- [ ] Request
+
+### Think of a better data structure for
+- [ ] from
+- [ ] join !!!
+- [ ] where !!!!!! Support for rails like syntax with hash?

data/Rakefile

@@ -0,0 +1,6 @@
+# require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/helper.rb

@@ -0,0 +1,5 @@
+class Array
+  def second
+    self[1]
+  end
+end

data/lib/terrazine.rb

@@ -0,0 +1,59 @@
+require_relative 'helper.rb'
+require_relative 'terrazine/config'
+require_relative 'terrazine/builder'
+require_relative 'terrazine/constructor'
+require_relative 'terrazine/type_map'
+require_relative 'terrazine/presenter'
+require_relative 'terrazine/result'
+
+module Terrazine
+
+  def self.connection
+    Config.connection
+  end
+
+  def self.config(params)
+    Config.set params
+  end
+
+  def self.send_request(structure, params = {})
+    sql = build_sql structure
+    connection = Config.connection!(params[:connection])
+
+    res = time_output(sql) { execute_request connection, sql }
+    Result.new res, params
+  end
+
+  def self.new_constructor(structure = {})
+    Constructor.new structure
+  end
+
+  def self.build_sql(structure)
+    case structure
+    when Hash
+      new_constructor(structure).build_sql
+    when Constructor
+      structure.build_sql
+    when String
+      structure
+    else
+      raise # TODO: Errors
+    end
+  end
+
+  def self.time_output(str = '')
+    time = Time.now
+    res = yield
+    puts "(\033[32m#{(Time.now - time) * 1000})ms \033[34m#{str}\033[0m"
+    res
+  end
+
+  # TODO: relocate
+  def self.execute_request(connection, sql)
+    if sql.is_a?(Array)
+      connection.exec_params(sql.first, sql.second)
+    else
+      connection.exec(sql)
+    end
+  end
+end

data/lib/terrazine/builder.rb

@@ -0,0 +1,251 @@
+module Terrazine
+  # build structures in to sql string
+  class Builder
+    attr_accessor :sql, :constructor
+
+    def initialize(constructor)
+      @constructor = constructor
+      @params = []
+    end
+
+    # TODO: update, delete, insert.....
+    def build_sql(structure)
+      structure = structure.is_a?(Constructor) ? structure.structure : structure
+      sql = ''
+      sql += "WITH #{build_with(structure[:with])} " if structure[:with]
+      # puts "build_sql, structure: #{structure}"
+      [:union, :select, :insert, :update, :delete, :set, :from, :join, :where,
+       :group, :order, :limit, :offset].each do |i|
+         next unless structure[i]
+         sql += send("build_#{i}".to_sym, structure[i])
+       end
+      sql
+    end
+
+    # get complete sql structure for constructor.
+    def get_sql(structure)
+      sql = build_sql structure
+      res = @params.count.positive? ? [sql, @params] : sql
+      @params = []
+      res
+    end
+
+    def build_with(structure)
+      if structure.second.is_a? Hash
+        "#{structure.first} AS (#{build_sql(structure.last)})"
+      else
+        structure.map { |v| build_with(v) }.join ', '
+      end
+    end
+
+    # def build_select_query(structure)
+    # puts "build_select_query, structure: #{structure}"
+    # sql += build_select(structure[:select], structure[:distinct]) if structure[:select]
+    # [:from, :join, :where, :order, :limit, :offset].each do |i|
+    # sql += send("build_#{i}", structure[i]) if structure[i]
+    # end
+    # end
+
+    def build_union(structure)
+      structure.map { |i| build_sql(i) }.join ' UNION '
+    end
+
+    def build_distinct_select(distinct)
+      case distinct
+      when Array
+        "DISTINCT ON(#{build_columns fields}) "
+      when true
+        'DISTINCT '
+      end
+    end
+
+    def build_select(structure, distinct = nil)
+      # puts "build_select, structure #{structure}"
+      "SELECT #{build_distinct_select distinct}#{build_columns structure} "
+    end
+
+    def build_tables(structure)
+      case structure
+      when Array
+        if check_alias(structure.first) # VALUES function or ...?
+          build_function(structure)
+        # if it's a array with strings/values
+        elsif structure.select { |i| i.is_a? Array }.empty? # array of table_name and alias
+          structure.join ' '
+        else # array of tables/values
+          structure.map { |i| i.is_a?(Array) ? build_tables(i) : i }.join(', ')
+        end
+      when String, Symbol
+        structure
+      else
+        raise "Undefined structure for FROM - #{structure}"
+      end
+    end
+
+    def build_from(structure)
+      "FROM #{build_tables(structure)} "
+    end
+
+    def conditions_constructor(structure, joiner = :and, level = nil)
+      case structure
+      when Array
+        key = structure.first
+        # AND, OR support
+        if key.is_a? Symbol
+          res = structure.drop(1).map { |i| conditions_constructor(i) }.join " #{key} ".upcase
+          level ? res : "(#{res})"
+        # Sub Queries support - ['rgl IN ?', {...}]
+        elsif key =~ /\?/
+          if [Hash, Constructor].include?(structure.second.class)
+            key.sub(/\?/, "(#{build_sql(structure.second)})")
+          else
+            key.sub(/\?/, build_param(structure.second))
+          end
+        else
+          res = structure.map { |i| conditions_constructor(i) }.join " #{joiner} ".upcase
+          level ? res : "(#{res})"
+        end
+      when String
+        structure
+      end
+    end
+
+    # TODO? conditions like [:eq :name :Aeonax]
+    def build_conditions(structure)
+      conditions_constructor(structure, :and, true) + ' '
+    end
+
+    # TODO: -_-
+    def build_join(structure)
+      if structure.is_a? Array
+        # TODO: hash is sux here -_- !!!!!!
+        if structure.second.is_a? Hash
+          name = build_tables structure.first # (name.is_a?(Array) ? name.join(' ') : name)
+          v = structure.second
+          "#{v[:option].to_s.upcase + ' ' if v[:option]}JOIN #{name} ON #{build_conditions v[:on]}"
+        else
+          structure.map { |i| build_join(i) }.join
+        end
+      else
+        structure =~ /join/i ? structure : "JOIN #{structure} "
+      end
+    end
+
+    def build_where(structure)
+      "WHERE #{build_conditions(structure)} "
+    end
+
+    # TODO!
+    def build_order(structure)
+      "ORDER BY #{structure} "
+    end
+
+    def build_limit(limit)
+      "LIMIT #{limit || 8} "
+    end
+
+    def build_offset(offset)
+      "OFFSET #{offset || 0} "
+    end
+
+    private
+
+    def build_param(value)
+      # no need for injections check - pg gem will check it
+      @params << value
+      "$#{@params.count}"
+    end
+
+    # all functions and column aliases begins from _
+    def check_alias(val)
+      val.to_s =~ /^_/
+    end
+
+    def iterate_hash(data)
+      iterations = []
+      data.each { |k, v| iterations << yield(k, v) }
+      iterations.join ', '
+    end
+
+    def build_as(field, name)
+      "#{field} AS #{name.to_s.sub(/^_/, '')}" # update ruby for delete_prefix? =)
+    end
+
+    def build_columns(structure, prefix = nil)
+      case structure
+      when Array
+        # SQL function - in format: "_#{fn}"
+        if check_alias(structure.first)
+          build_function structure, prefix
+        else
+          structure.map { |i| build_columns i, prefix }.join ', '
+        end
+      when Hash
+        # sub_query
+        if structure[:select]
+          "(#{build_sql(structure)})"
+        # colum OR table alias
+        else
+          iterate_hash(structure) do |k, v|
+            if check_alias(k)
+              build_as(build_columns(v, prefix), k)
+            else
+              build_columns(v, k.to_s)
+            end
+          end
+        end
+      when Symbol, String
+        structure = structure.to_s
+        if prefix && structure !~ /, |\./
+          "#{prefix}.#{structure}"
+        else
+          structure
+        end
+      when Constructor
+        "(#{build_sql structure.structure})"
+      when true # choose everything -_-
+        build_columns('*', prefix)
+      else # TODO: values from value passing here... -_-
+        structure
+        # raise "Undefined class: #{structure.class} of #{structure}" # TODO: ERRORS class
+      end
+    end
+
+    # TODO!!!!!!! Relocate in class FunctionsBuilder? and send function name in it.
+    def build_function(structure, prefix = nil)
+      function = structure.first.to_s.sub(/^_/, '')
+      arguments = structure.drop(1)
+      case function.to_sym
+      when :param
+        build_param arguments.first
+      when :count # TODO? alias support on this lvl
+        if arguments.count > 1
+          arguments.map { |i| "COUNT(#{build_columns(i, prefix)})" }.join ','
+        else
+          "COUNT(#{build_columns(arguments.first, prefix)})"
+        end
+      when :nullif
+        # TODO? querry for value
+        "NULLIF(#{build_columns(arguments.first, prefix)}, #{arguments[1]})"
+      when :array # TODO? build_columns support
+        if [Hash, Constructor].include?(arguments.first.class)
+          "ARRAY(#{build_sql arguments.first})"
+        else # TODO? condition and error case
+          "ARRAY[#{arguments.join ', '}]"
+        end
+      when :avg
+        "AVG(#{build_columns(arguments.first, prefix)})"
+      when :values
+        "(VALUES(#{build_columns arguments.first, prefix})) AS #{structure[2]} (#{build_columns arguments.last})"
+      when :case
+        else_val = "ELSE #{arguments.pop} " unless arguments.last.is_a? Array
+        conditions = arguments.map { |i| "WHEN #{i.first} THEN #{i.last}" }.join ' '
+        "CASE #{conditions} #{else_val}END"
+      when :coalesce
+        "COALESCE(#{build_columns(arguments, prefix)})"
+      else
+        raise "Unknown function #{function}" # TODO: errors-_-
+      end
+    end
+  end
+end

data/lib/terrazine/config.rb

@@ -0,0 +1,19 @@
+module Terrazine
+  class Config
+    class << self
+      def set(params)
+        # another way?
+        @@connection = params[:connection] if params[:connection]
+      end
+
+      def connection(conn = nil)
+        @@connection ||= conn
+        conn || @@connection
+      end
+
+      def connection!(conn = nil)
+        connection(conn) || raise # TODO: error
+      end
+    end
+  end
+end

data/lib/terrazine/constructor.rb

@@ -0,0 +1,163 @@
+module Terrazine
+  class Constructor
+    attr_reader :structure, :params
+    def initialize(structure = {})
+      @structure = structure
+      # @params = []
+      @builder = Builder.new(self)
+    end
+
+    # TODO? join hash inside array?
+    # TODO!! join values of existing keys
+    def structure_constructor(structure, modifier)
+      return modifier unless structure
+
+      if structure.is_a?(Hash) && modifier.is_a?(Hash)
+        modifier.each do |k, v|
+          structure[k] = structure_constructor(structure[k], v)
+        end
+        structure
+      else
+        structure = structure.is_a?(Array) ? structure : [structure]
+        if modifier.is_a?(Array)
+          modifier.each { |i| structure_constructor structure, i }
+        else
+          structure << modifier
+        end
+        structure.uniq
+      end
+    end
+
+    # just string
+    ### select "name, email"
+
+    # array of strings or symbols
+    ### select [*selectable_fields]
+
+    # hash with column aliases
+    ### select _field_alias: :field
+    ### => 'SELECT field AS field_alias '
+
+    # array of fields and aliases - order doesnt matter
+    ### select [{ _user_id: :id, _user_name: :name }, :password]
+    ### => 'SELECT id AS user_id, name AS user_name, password '
+
+    # functions - array with first value - function name with underscore as symbol
+    ### select [:_nullif, :row, :value]
+
+    # table alias/name
+    ### select t_a: [{ _user_id: :id }, :field_2, [:_nullif, :row, :value]]
+    ### => 'SELECT t_a.id AS user_id, t_a.password, NULLIF(t_a.row, value) '
+
+    # any nesting and sub queries as new SQLConstructor or hash structure
+    ### select u: [{ _some_count: [:_count, [:_nullif, :row, :value]] },
+    ###            :name, :email],
+    ###        _u_count: (another_constructor || another_structure)
+    ### => 'SELECT COUNT(NULLIF(u,row, value)) AS some_count, u.name, u.email, (SELECT ...) AS u_count '
+
+    # construct it
+    ### constructor = SQLConstructor.new from: [:users, :u],
+    ###                                  join [[:mrgl, :m], { on: 'm.user_id = u.id'}]
+    ### constructor.select :name
+    ### constructor.select [{u: :id, _some_count: [:_count, another_constructor]}] if smthng
+    ### constructor.select [{r: :rgl}, :zgl] if another_smthng
+    ### constructor.build_sql
+    ### => 'SELECT name, u.id, COUNT(SELECT ...) AS some_count, r.rgl, zgl FROM ...'
+    def select(structure)
+      @structure[:select] = structure_constructor(@structure[:select], structure)
+      self
+    end
+
+    # distinct_select select_structure
+    # distinct_select select_structure, distinct_field
+    # distinct_select select_structure, [*distinct_fields]
+    def distinct_select(structure, fields = nil)
+      @structure[:distinct] = fields || true
+      select structure
+      self
+    end
+
+    # TODO: from construction
+    # from [:mrgl, :m]
+    # from [:_values, [1, 2], :rgl, [:zgl, :gl]]
+    # => [[:mrgl, :m], [:_values, [1, 2], :rgl, [:zgl, :gl]]]
+    def from(structure)
+      @structure[:from] = structure
+      self
+    end
+
+    # TODO: join constructor AND better syntax
+    # join 'users u ON u.id = m.user_id'
+    # join ['users u ON u.id = m.user_id',
+    #       'skills s ON u.id = s.user_id']
+    # join [[:user, :u], { on: 'rgl = 123' }]
+    # join [[[:user, :u], { option: :full, on: [:or, 'mrgl = 2', 'rgl = 22'] }],
+    #       [:master, { on: ['z = 12', 'mrgl = 12'] }]]
+    def join(structure)
+      @structure[:join] = structure
+      # puts @structure[:join]
+      self
+    end
+
+    # conditions 'mrgl = 12'
+    # conditions ['z = 12', 'mrgl = 12']
+    # conditions ['NOT z = 13', [:or, 'mrgl = 2', 'rgl = 22']]
+    # conditions [:or, ['NOT z = 13', [:or, 'mrgl = 2', 'rgl = 22']],
+    #                  [:or, 'rgl = 12', 'zgl = fuck']]
+    # conditions [['NOT z = 13',
+    #             [:or, 'mrgl = 2', 'rgl = 22']],
+    #             [:or, 'rgl = 12', 'zgl = fuck']]
+    # => 'NOT z = 13 AND (mrgl = 2 OR rgl = 22) AND (rgl = 12 OR zgl = fuck)'
+    # conditions ['NOT z = 13', [:or, 'mrgl = 2',
+    #                                 ['rgl IN ?', {select: true, from: :users}]]]
+
+    # constructor.where ['u.categories_cache ~ ?',
+    #                           { select: :path, from: :categories,
+    #                             where: ['id = ?', s_params[:category_id]] }]
+    # constructor.where('m.cashless IS TRUE')
+    def where(structure)
+      w = @structure[:where]
+      if w.is_a?(Array) && w.first.is_a?(Array)
+        @structure[:where].push structure
+      elsif w
+        @structure[:where] = [w, structure]
+      else
+        @structure[:where] = structure
+      end
+      self
+    end
+
+    # TODO: with -_-
+    # with [:alias_name, { select: true, from: :users}]
+    # with [[:alias_name, { select: true, from: :users}],
+    #       [:alias_name_2, { select: {u: [:name, :email]},
+    #                         from: :rgl}]]
+
+    def limit(per)
+      @structure[:limit] = (per || 8).to_i
+      self
+    end
+
+    # TODO: serve - return count of all rows
+    # params - hash with keys :per, :page
+    def paginate(params)
+      limit params[:per]
+      @structure[:offset] = ((params[:page]&.to_i || 1) - 1) * @structure[:limit]
+      self
+    end
+
+    # just rewrite data. TODO: merge with merge without loss of data?
+    # constructor.merge(select: :content, order_by: 'f.id DESC', limit: 1)
+    def merge(params)
+      @structure.merge! params
+      self
+    end
+
+    # constructor.build_sql
+    # => 'SELECT .... FROM ...'
+    # => ['SELECT .... FROM .... WHERE id = $1', [22]]
+    def build_sql
+      @builder.get_sql @structure
+    end
+  end
+end

data/lib/terrazine/presenter.rb

@@ -0,0 +1,39 @@
+module Terrazine
+  # convinient for API presenter
+  class Presenter
+    class << self
+      # TODO: delete fields
+      def present(result, options)
+        if options[:array] || result.count > 1
+          return [] if result.count.zero?
+          result.map { |i| present_row i, options[:structure] }
+        else
+          return nil if result.count.zero?
+          present_row result, options[:structure]
+        end
+      end
+
+      def present_row(row, structure)
+        hash = row.to_h
+        if structure.present?
+          structure.each do |k, v|
+            hash[k] = present_value(row, v)
+          end
+        end
+        hash.compact
+      end
+
+      # TODO!!!
+      def present_value(row, modifier)
+        case modifier
+        when Result
+          modifier.present
+        when Proc
+          present_value row, modifier.call(row)
+        else
+          modifier
+        end
+      end
+    end
+  end
+end

data/lib/terrazine/result.rb

@@ -0,0 +1,69 @@
+require 'forwardable'
+
+module Terrazine
+  # respresent result row
+  class Row
+    extend Forwardable
+    # attr_reader :pg_result, :values
+    def initialize(pg_result, values)
+      # @pg_result = pg_result
+      # @values = values
+      # Hiding from console a lot of data lines-_- ... another method?
+      define_singleton_method(:pg_result) { pg_result }
+      define_singleton_method(:values) { values }
+    end
+
+    def respond_to_missing?(method_name, include_all = true)
+      index(method_name.to_s) || super
+    end
+
+    def method_missing(method_name, *_)
+      indx = index(method_name.to_s)
+      indx || super
+      return unless values
+      values[indx]
+    end
+
+    def to_h
+      return {} unless values.present?
+      pg_result.fields.zip(values).to_h
+    end
+
+    def_delegator :pg_result, :index
+  end
+
+  # inheritance from row for delegation methods to first row... may be method missing?
+  class Result < Row
+    attr_reader :rows, :fields, :options
+
+    # TODO: as arguments keys, values and options? Future support of another db?
+    # arguments - PG::Result instance and hash of options
+    def initialize(result, options)
+      # how another db parsing data?
+      TypeMap.update(result, options[:types]) if options[:types]
+
+      @options = options
+      @fields = result.fields
+      @rows = []
+      result.each_row { |i| @rows << Row.new(self, i) }
+      result.clear # they advise to clear it, but maybe better to use it until presenter?
+    end
+
+    def present(o = {})
+      options = @options[:presenter_options] ? o.merge(@options[:presenter_options]) : o
+      Presenter.present(self, options)
+    end
+
+    # ResultRow inheritance support
+    def values
+      first&.values
+    end
+
+    def pg_result
+      self
+    end
+
+    def_delegators :@rows, :each, :each_with_index, :first, :last, :map, :count, :present?
+    def_delegator :@fields, :index
+  end
+end

data/lib/terrazine/type_map.rb

@@ -0,0 +1,63 @@
+require 'pg'
+require 'pg_hstore'
+
+module Terrazine
+  # PG type map updater
+  class TypeMap
+    class << self
+      def update(pg_result, types)
+        # TODO! why it sometimes column_map?
+        t_m = pg_result.type_map
+        columns_map = t_m.is_a?(PG::TypeMapByColumn) ? t_m : t_m.build_column_map(pg_result)
+        coders = columns_map.coders.dup
+        types.each do |name, type|
+          coders[pg_result.fnumber(name.to_s)] = fetch_text_decoder type
+        end
+        pg_result.type_map = PG::TypeMapByColumn.new coders
+      end
+
+      def fetch_text_decoder(type)
+        # decoder inside decoder
+        # as example array of arrays with integers - type == [:array, :array, :integer]
+        if type.is_a?(Array)
+          decoder = new_text_decoder type.shift
+          assign_elements_type type, decoder
+        else
+          new_text_decoder type
+        end
+      end
+
+      def assign_elements_type(types, parent)
+        parent.elements_type = if types.count == 1
+                                 select_text_decoder(types.shift).new
+                               else
+                                 type = types.shift
+                                 assign_elements_type(types, select_text_decoder(type))
+                               end
+        parent
+      end
+
+      def new_text_decoder(type)
+        select_text_decoder(type).new
+      end
+
+      def select_text_decoder(type)
+        decoder = { array: PG::TextDecoder::Array,
+                    float: PG::TextDecoder::Float,
+                    boolaen: PG::TextDecoder::Boolean,
+                    integer: PG::TextDecoder::Integer,
+                    date: PG::TextDecoder::TimestampWithoutTimeZone,
+                    hstore: Hstore,
+                    json: PG::TextDecoder::JSON }[type]
+        raise "Undefined decoder #{type}" unless decoder
+        decoder
+      end
+    end
+  end
+
+  class Hstore < PG::SimpleDecoder
+    def decode(string, _tuple = nil, _field = nil)
+      PgHstore.load(string, true) if string.is_a? String
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Terrazine
+  VERSION = '0.0.2'
+end

data/spec/constructor_spec.rb

@@ -0,0 +1,90 @@
+require_relative 'spec_helper'
+
+# TODO.... -_-
+describe Terrazine::Constructor do
+  before :each do
+    @constructor = Terrazine.new_constructor
+  end
+  before :all do
+    @permanent_c = Terrazine.new_constructor
+  end
+
+  it 'mrgl' do
+    expect(@constructor.class).to eql Terrazine::Constructor
+  end
+
+  context '`select`' do
+    it 'build simple structure' do
+      @constructor.select(:name)
+      @constructor.select('phone')
+      expect(structure(:select)).to eql [:name, 'phone']
+    end
+
+    it 'build hash structure' do
+      @constructor.select(u: [:name, :email])
+      @constructor.select _calls_count: [:_count, :connected]
+      expect(structure(:select)).to eq  u: [:name, :email],
+                                        _calls_count: [:_count, :connected]
+      expect(@constructor.build_sql).to eq 'SELECT u.name, u.email, COUNT(connected) AS calls_count '
+    end
+
+    it 'build sub_queries' do
+      @constructor.select select: [:_count, [:_nullif, :connected, true]],
+                          from: [:calls, :c],
+                          where: 'u.id = c.user_id'
+      expect(@constructor.build_sql).to eq 'SELECT (SELECT COUNT(NULLIF(connected, true)) FROM calls c WHERE u.id = c.user_id  ) '
+    end
+
+    it 'build big structures' do
+      @permanent_c.select _calls_count: { select: [:_count, [:_nullif, :connected, true]],
+                                          from: [:calls, :c],
+                                          where: 'u.id = c.user_id' },
+                          u: [:name, :phone, { _master: [:_nullif, :role, "'master'"] },
+                              'u.abilities, u.id', 'birthdate']
+      @permanent_c.select o: :client_name
+      @permanent_c.select :secure_id
+      expect(@permanent_c.build_sql).to eq "SELECT (SELECT COUNT(NULLIF(connected, true)) FROM calls c WHERE u.id = c.user_id  ) AS calls_count, u.name, u.phone, NULLIF(u.role, 'master') AS master, u.abilities, u.id, u.birthdate, o.client_name, secure_id "
+    end
+  end
+
+  context '`from`' do
+    it 'build simple data structures' do
+      @constructor.from :users
+      expect(@constructor.build_sql).to eq 'FROM users '
+      @permanent_c.from [:users, :u]
+      expect(@permanent_c.build_sql).to match 'o.client_name, secure_id FROM users u $'
+    end
+
+    it 'build values' do
+      @constructor.from [:_values, [:_param, 'mrgl'], :r, ['type']]
+      expect(@constructor.build_sql).to eq ['FROM (VALUES($1)) AS r (type) ', ['mrgl']]
+    end
+
+    it 'build values and tables' do
+      @constructor.from [[:mrgl, :m], [:_values, [1, 2], :rgl, [:zgl, :gl]]]
+      expect(@constructor.build_sql).to eq 'FROM mrgl m, (VALUES(1, 2)) AS rgl (zgl, gl) '
+    end
+  end
+
+  context '`join`' do
+    it 'build simple join' do
+      @constructor.join 'users u ON u.id = m.user_id'
+      expect(@constructor.build_sql).to eq 'JOIN users u ON u.id = m.user_id '
+      @constructor.join ['users u ON u.id = m.user_id',
+                         'skills s ON u.id = s.user_id']
+      expect(@constructor.build_sql).to eq 'JOIN users u ON u.id = m.user_id JOIN skills s ON u.id = s.user_id '
+    end
+
+    it 'build big structures' do
+      @permanent_c.join [[[:masters, :m], { on: 'm.user_id = u.id' }],
+                         [[:attachments, :a], { on: ['a.user_id = u.id',
+                                                     'a.type = 1'],
+                                                option: :left}]]
+      expect(@permanent_c.build_sql).to match 'FROM users u JOIN masters m ON m.user_id = u.id LEFT JOIN attachments a ON a.user_id = u.id AND a.type = 1 $'
+    end
+  end
+
+  context '`conditions`' do
+    
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require_relative '../lib/terrazine'
+
+def structure(key)
+  @constructor.structure[key]
+end

data/spec/terrazin_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../lib/terrazine'
+
+describe Terrazine do
+  
+end

data/terrazine.gemspec

@@ -0,0 +1,27 @@
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+
+require 'version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'terrazine'
+  spec.version       = Terrazine::VERSION
+  spec.authors       = ['Aeonax']
+  spec.email         = ['aeonax.liar@gmail.com']
+
+  spec.summary       = %q(Terrazine is a parser of data structures in to SQL)
+  spec.description   = %q(You can take a look at [github]{https://github.com/Aeonax/terrazine}.)
+  spec.homepage      = 'https://github.com/Aeonax/terrazine'
+  spec.license       = 'MIT'
+
+  spec.files            = `git ls-files`.split("\n")
+  spec.test_files       = `git ls-files -- {spec,features}/*`.split("\n")
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+
+  spec.add_dependency 'pg-hstore', '1.2.0'
+
+  spec.required_ruby_version   =  '>= 2.3.0'
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: terrazine
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Aeonax
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pg-hstore
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: You can take a look at [github]{https://github.com/Aeonax/terrazine}.
+email:
+- aeonax.liar@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/helper.rb
+- lib/terrazine.rb
+- lib/terrazine/builder.rb
+- lib/terrazine/config.rb
+- lib/terrazine/constructor.rb
+- lib/terrazine/presenter.rb
+- lib/terrazine/result.rb
+- lib/terrazine/type_map.rb
+- lib/version.rb
+- spec/constructor_spec.rb
+- spec/spec_helper.rb
+- spec/terrazin_spec.rb
+- terrazine.gemspec
+homepage: https://github.com/Aeonax/terrazine
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.1
+signing_key: 
+specification_version: 4
+summary: Terrazine is a parser of data structures in to SQL
+test_files: []