eql 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2aec3fe36fce2efd0f4d5fd05f4ae6c8822c83a0
+  data.tar.gz: a00651310daeb5909ba5a4538ad7f3067764ed97
+SHA512:
+  metadata.gz: 478099d1d7c7ca2f10d7e9df0a774350e7ee5e9ceda5fd8858f4351e8f44545c5713055571a06720299dfc9019f3b368828f22913cbb542ce1939cb1fbddc3eb
+  data.tar.gz: a95e2015c4e01699ae5b136e00e2065add263afa0cf1d92e0a5016fa830ad37dafc7680b50c382bc75967a311d9dd83deee7daf05f34ab5159adc8eb50767c3b

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Oleg Yashchuk
+
+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,113 @@
+# Eql
+[![Build Status](https://travis-ci.org/zoer/eql.svg)](https://travis-ci.org/zoer/eql)
+[![Code Climate](https://codeclimate.com/github/zoer/eql/badges/gpa.svg)](https://codeclimate.com/github/zoer/eql)
+[![Version Eye](https://www.versioneye.com/ruby/eql/badge.png)](https://www.versioneye.com/ruby/eql)
+[![Inline docs](http://inch-ci.org/github/zoer/eql.png)](http://inch-ci.org/github/zoer/eql)
+[![Gem Version](https://badge.fury.io/rb/eql.svg)](http://badge.fury.io/rb/eql)
+
+Eql provides an ability to create raw DB queries via ERB templates.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'eql'
+```
+
+## Usage
+
+### Simple usage
+
+```erb
+# queries/update.sql.erb
+<% each do |item| %>
+  INSERT INTO items (category, name)
+    VALUES (<%= item.values_at(:category, :name).map { |i| quote(i) }.join(', ')) %>
+    ON CONFILICT (category, name) DO NOTHING
+<% end %>
+```
+
+```ruby
+b = Eql.new('queries')
+b.execute(update, [{category: 'cars', name: 'BMW'}, {category: 'cars', name: 'AUDI'}])
+```
+
+### Inline templates
+
+```ruby
+b = Eql.template <<-ERB
+  SELECT products
+    FROM customer c
+      LEFT JOIN products p ON (c.id = p.customer_id)
+    WHERE c.id = <%= quote(id) %>
+ERD
+b.execute_params(id: 74)
+```
+
+### Usage with Rails
+
+```ruby
+# config/initializers/eql.rb
+
+Eql.configure do |config|
+  config.path = Rails.root.join('app/queries')
+  config.adapter = :active_record
+end
+```
+
+```erb
+# app/queries/fresh_items.sql.erb
+SELECT *
+  FROM items
+  WHERE outdated IS DISTINCT FROM TRUE
+  LIMIT <%= limit %>
+```
+
+```ruby
+  outdated = Eql.execute(:fresh_items, limit: 10)
+```
+
+### Create your own adapter
+
+```
+class BashAdapter < Eql::Adapters::Base
+  def self.match?(conn)
+    conn == :my_bash
+  end
+
+  def command
+    "bash << eof\n" \
+      "#{render}\n" \
+    "eof\n"
+  end
+
+
+  def execute
+    `#{command}`
+  end
+end
+
+Eql.register_adapter(:my_bash, BashAdapter)
+
+b = Eql.new(nil, :my_bash)
+b.template <<-COMMAND
+  mkdir -p <%= folder %>
+  find . -name *.rb -not *_spec.rb -type f -exec mv {} <%= folder %> \;
+  ls folder/*
+COMMAND
+b.execute_params(folder: 'units')
+``
+
+### Adapters
+Now implemented only `ActiveRecord` adapter. Please, fill free to contribute on
+a new adapter.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/zoer/eql.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/eql/adapter_factory.rb

@@ -0,0 +1,61 @@
+module Eql
+  #
+  # AdapterFactory class detects adapters and their helpers
+  #
+  class AdapterFactory
+    class << self
+      # @return [Symbol]
+      HELPERS_MODULE_NAME = :ContextHelpers
+
+      #
+      # Registered adapters
+      #
+      # @return [Hash{Symbol => Eql::Adapters::Base}]
+      #
+      def adapters
+        @adapters ||= {}
+      end
+
+      #
+      # Register a new adapter
+      #
+      # @param [Symbol] key adapter's key
+      # @param [Eql::Adapters::Base] klass adapter's class
+      #
+      def register_adapter(key, klass)
+        adapters[key] = klass
+      end
+
+      #
+      # Get adapter's helper modules
+      #
+      # @param [Eql::Adapters::Base] adapter
+      #
+      # @return [Array<Module>]
+      #
+      def adapter_helpers(adapter)
+        adapter.class.ancestors.each_with_object([]) do |klass, ret|
+          next unless klass.is_a?(Class)
+          next unless klass.const_defined?(HELPERS_MODULE_NAME)
+          ret.unshift klass.const_get(HELPERS_MODULE_NAME)
+        end
+      end
+
+      #
+      # Detect adapter class
+      #
+      # @raise [RuntimeError] when can't find adapter's class
+      #
+      # @param [Object, nil] conn DB connection or a cursor
+      #
+      # @return [Eql::Adapters::Base]
+      #
+      def factory(conn)
+        return Eql.config.default_adapter unless conn
+        adapters.values.find { |a| a.match?(conn) if a.respond_to?(:match?) }.tap do |adapter|
+          raise "Unable to detect adapter for #{conn.inspect}" unless adapter
+        end
+      end
+    end
+  end
+end

data/lib/eql/adapters/active_record.rb

@@ -0,0 +1,66 @@
+module Eql
+  module Adapters
+    #
+    # ActiveRecord class is a ActiveRecord::Base adapter
+    #
+    class ActiveRecord < Base
+      #
+      # ContextHelpers module contains template's helpers
+      #
+      module ContextHelpers
+        #
+        # Quote string
+        #
+        # @param [String] val string to quote
+        #
+        # @return [String] returns safety quoted string
+        #
+        def quote(val)
+          ::ActiveRecord::Base.connection.quote(val)
+        end
+      end
+
+      #
+      # @see Eql::Adapters::Base#match?
+      #
+      def self.match?(conn)
+        defined?(::ActiveRecord::Base) &&
+          conn.is_a?(::ActiveRecord::ConnectionAdapters::AbstractAdapter)
+      end
+
+      #
+      # Get rendered SQL
+      #
+      # @return [Stirng]
+      #
+      def sql
+        builder.render
+      end
+
+      #
+      # @see Eql::Adapters::Base#extension
+      #
+      def extension
+        '.{sql.erb,erb.sql}'
+      end
+
+      #
+      # @see Eql::Adapters::Base#execute
+      #
+      def execute
+        conn.execute(sql).to_a
+      end
+
+      #
+      # Get DB connection to execute a query
+      #
+      # @return [ActiveRecord::ConnectionAdapters::AbstractAdapter]
+      #
+      def conn
+        builder.conn || ::ActiveRecord::Base.connection
+      end
+    end
+  end
+end
+
+Eql.register_adapter :active_record, Eql::Adapters::ActiveRecord

data/lib/eql/adapters/base.rb

@@ -0,0 +1,53 @@
+module Eql
+  #
+  # Adapters module contains DB adapters
+  #
+  module Adapters
+    #
+    # Base class contains basic adapter logic
+    #
+    class Base
+      module ContextHelpers
+      end
+
+      # @return [Eql::Builder]
+      attr_reader :builder
+
+      #
+      # Does adapter match connection?
+      #
+      # @param [Object] conn
+      #
+      # @return [Boolean]
+      #
+      def self.match?(conn)
+        raise NotImplementedError
+      end
+
+      #
+      # @param [Eql::Builder] builder
+      #
+      def initialize(builder)
+        @builder = builder
+      end
+
+      #
+      # Execute adapter
+      #
+      # @return [Object] return exection results
+      #
+      def execute
+        raise NotImplementedError
+      end
+
+      #
+      # Get adapter's template extensions
+      #
+      # @return [String]
+      #
+      def extension
+        '.erb'
+      end
+    end
+  end
+end

data/lib/eql/builder.rb

@@ -0,0 +1,165 @@
+module Eql
+  #
+  # Builder class builds ERB templates and interact with adapters to run it.
+  #
+  class Builder
+    # @param [String] returns path to a root folder with templates
+    attr_reader :path
+    # @param [String] retruns DB connectionor a currsor
+    attr_reader :conn
+
+    #
+    # @param [String] path path to a root folder with templates
+    # @param [String] conn DB connection or a cursor
+    #
+    def initialize(path, conn)
+      @path = path
+      @conn = conn
+    end
+
+    #
+    # Load query's template and params
+    #
+    # @param [String] name template's name
+    # @param [Object] params query's params
+    #
+    def load(name = nil, params = nil)
+      load_template(name) if name
+      load_params(params) if params
+    end
+
+    #
+    # Load template with given name
+    #
+    # @param [String, Symbol] name template's name
+    #
+    def load_template(name)
+      @template_content = File.read(resolve_path(name))
+    end
+
+    #
+    # Load query's params
+    #
+    # @param [Object] params
+    #
+    def load_params(params)
+      @params = params
+    end
+
+    #
+    # Set content template
+    #
+    # @param [String] raw template's content
+    #
+    def template(raw)
+      @template_content = raw
+    end
+
+    #
+    # Proxy's adapter
+    #
+    # @retrn [Eql::Adapters::Base]
+    #
+    def adapter
+      @adapter ||= AdapterFactory.factory(conn).new(self)
+    end
+
+    #
+    # Template's content
+    #
+    # @return [String]
+    #
+    def template_content
+      @template_content.to_s
+    end
+
+    class H < Hash
+      def name
+        :h
+      end
+    end
+
+    #
+    # Render a template
+    #
+    # @return [String] returns rendered templated
+    #
+    def render
+      ERB.new(template_content).result(proxy_class.new(self, @params).get_binding)
+    end
+
+    #
+    # Proxy class for template
+    #
+    # @return [Eql::Proxy]
+    #
+    def proxy_class
+      Eql::Proxy.generate(adapter)
+    end
+
+    #
+    # File template to find
+    #
+    # @param [String, Symbol] file template's name
+    #
+    # @return [String] returns file path pattern
+    #
+    def template_path(file)
+      File.join(@path.to_s, file.to_s) + adapter.extension
+    end
+
+    #
+    # Resolve file's path
+    #
+    # @raise [RuntimeError] when can't wind a file
+    #
+    # @param [String] file template's name
+    #
+    # @return [String] returns template's path
+    #
+    def resolve_path(file)
+      path = template_path(file)
+      Dir.glob(path).first.tap do |f|
+        raise "Unable to find query template with #{path.inspect} location" unless f
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      adapter.send(name, *args, &block)
+    end
+
+    #
+    # Execute template query
+    #
+    # @param [String, Symbol] tmpl template's name
+    # @param [Object, nil] params o
+    #
+    # @return [Object] returns execution results
+    #
+    def execute(tmpl = nil, params = nil)
+      load(tmpl, params)
+      adapter.execute
+    end
+
+    #
+    # Execute params with a query
+    #
+    # @param [Object] params
+    #
+    # @return [Object] returns execution results
+    #
+    def execute_params(params = nil)
+      load_params(params)
+      adapter.execute
+    end
+
+    #
+    # Clone current builder
+    #
+    # @return [Eql::Builder]
+    #
+    def clone
+      self.class.new(path, conn)
+    end
+  end
+end

data/lib/eql/config.rb

@@ -0,0 +1,30 @@
+module Eql
+  #
+  # Config class holds rendering settings
+  #
+  class Config
+    # @param [String]
+    attr_accessor :path
+    # @param [Symbol]
+    attr_accessor :adapter
+
+    def initialize
+      @adapter = :active_record
+    end
+
+    #
+    # @return [String] returns templates root folder
+    #
+    def path
+      @path ||= defined?(Rails) ? Rails.root : Dir.pwd
+    end
+
+    #
+    # @return [Eql::Adapters::Base] returns default adapter
+    #
+    def default_adapter
+      return unless adapter
+      @default_adapter ||= AdapterFactory.adapters[adapter]
+    end
+  end
+end

data/lib/eql/proxy.rb

@@ -0,0 +1,84 @@
+module Eql
+  #
+  # Proxy class proxies adapaters helpers and params to a template
+  #
+  class Proxy
+    #
+    # @param [Eql::Builder] builder
+    # @param [Object] params template's params to proxy
+    #
+    def initialize(builder, params = nil)
+      @builder = builder
+      @params = params
+      if @params.is_a?(Hash)
+        @params = params.keys.each_with_object({}) do |key, ret|
+          ret[key.respond_to?(:to_sym) ? key.to_sym : key] = params[key]
+        end
+      end
+    end
+
+    #
+    # Render partial template
+    #
+    # @param [String] tmpl partial's name
+    # @param [Object] params template's params
+    #
+    # @return [String] returns rendered template
+    #
+    def render(tmpl, params = nil)
+      b = @builder.clone
+      b.load(tmpl, params)
+      b.render
+    end
+
+    def method_missing(name, *args, &block)
+      return @params[name] if @params.is_a?(Hash) && @params.key?(name)
+      @params.send(name, *args, &block)
+    end
+
+    def respond_to_missing?(name, *)
+      @params.is_a?(Hash) && @params.key?(name) ||
+        @params.respond_to?(name) ||
+        super
+    end
+
+    #
+    # Get proxy binding
+    #
+    # @return [Binding]
+    #
+    def get_binding
+      # binding.name  # => :binding
+      # if we have variable with the 'name' name we need to make a closure
+      name = send(:name) if respond_to?(:name)
+      binding
+    end
+
+    class << self
+      #
+      # Cached generated proxy classes
+      #
+      # @return [Hash{Symbol => Eql::Proxy}]
+      #
+      def generated
+        @generated ||= {}
+      end
+
+      #
+      # Generate a proxy class for given adapter
+      #
+      # @param [Eql::Adapters::Base] adapter
+      #
+      # @return [Eql::Proxy] returns generated class
+      #
+      def generate(adapter)
+        generated[adapter.class] ||= begin
+          helpers = AdapterFactory.adapter_helpers(adapter)
+          Class.new(self) do
+            helpers.each { |h| include h }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eql/version.rb

@@ -0,0 +1,4 @@
+module Eql
+  # @return [String] returns gem version
+  VERSION = '0.0.1'
+end

data/lib/eql.rb

@@ -0,0 +1,85 @@
+require 'erb'
+
+#
+# Eql module renders ERB query templates and runs them
+#
+module Eql
+  class << self
+    #
+    # Create new builder
+    #
+    # @param [String, nil] path template's root folder
+    # @param [Object, nil] conn DB connection or cursor
+    #
+    def new(path = nil, conn = nil)
+      Builder.new(path || config.path, conn)
+    end
+
+    #
+    # Load a builder with template and params
+    #
+    # @param [String, Symbol] tmpl template's name
+    # @param [Object, nil] params template's params
+    #
+    # @return [Eql::Builder]
+    #
+    def load(tmpl, params = nil)
+      new.tap { |b| b.load(tmpl, params) }
+    end
+
+    #
+    # Execute a builder with template and params
+    #
+    # @param [String, Symbol] tmpl template's name
+    # @param [Object, nil] params template's params
+    #
+    # @return [Object] returns excution results
+    #
+    def execute(tmpl, params = nil)
+      load(tmpl, params).execute
+    end
+
+    #
+    # Load a builder with template content
+    #
+    # @param [String] erb template's content
+    #
+    # @return [Eql::Builder]
+    #
+    def template(erb)
+      new.tap { |b| b.template(erb) }
+    end
+
+    #
+    # @return [Eql::Config]
+    #
+    def config
+      @config ||= Config.new
+    end
+
+    #
+    # Setup
+    #
+    def configure
+      yield(config)
+    end
+
+    #
+    # @see Eql::AdapterFactory#redister_adapter
+    #
+    def register_adapter(key, klass)
+      AdapterFactory.register_adapter(key, klass)
+    end
+  end
+end
+
+%w[
+  version
+  config
+  proxy
+  builder
+  adapter_factory
+  adapters/base
+  adapters/active_record
+].each { |f| require_relative "eql/#{f}" }
+

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: eql
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Oleg Yashchuk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Create a raw query to your DB via ERB templates
+email:
+- oazoer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/eql.rb
+- lib/eql/adapter_factory.rb
+- lib/eql/adapters/active_record.rb
+- lib/eql/adapters/base.rb
+- lib/eql/builder.rb
+- lib/eql/config.rb
+- lib/eql/proxy.rb
+- lib/eql/version.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Erb Query Language
+test_files: []