hugg-orm 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fcefba25435c17f1d48c113fb95cd455999188bd
+  data.tar.gz: 9fa82007c4e17a0565d2e38098ea312eebfceefa
+SHA512:
+  metadata.gz: 98439bedf84eafe456465061514d3dd00d8e8d879cc82f81fceb8fb1236df73d4971ff409e8a8c16449d88301cf370a86ff9136e81fdef276aad3e7a2af3fa1d
+  data.tar.gz: 167741b1ed8bdd9970ab6cda82957a3b2e7f2466c4c1b5088e6126e9dfe22d801cf4beb4da1b403e35f6d80352462b3469dccc3626722b4831990309d7be4cd1

data/lib/hugg_orm.rb

@@ -0,0 +1,9 @@
+require 'active_support/all'
+
+require "hugg_orm/version"
+require "hugg_orm/connection"
+require "hugg_orm/persistence"
+require 'hugg_orm/query'
+
+module HuggORM
+end

data/lib/hugg_orm/connection.rb

@@ -0,0 +1,71 @@
+require 'forwardable'
+require 'pg'
+
+module HuggORM
+  class Connection
+    extend Forwardable
+
+    RETRIES = 1
+
+    attr_reader :options
+
+    def self.db
+      @_db ||= self.new
+    end
+
+    def connection
+      return @connection unless @connection.nil?
+      connect(@options)
+      @connection
+    end
+
+    def options(opts = {})
+      @options = opts
+    end
+
+    def connect(opts = {})
+      @options = opts
+      @connection = PG.connect(opts)
+      self
+    end
+
+    def disconnect
+      connection.finish if @connection
+      @connection = nil
+      self
+    end
+
+    def reconnect
+      disconnect
+      connect(@options)
+      self
+    end
+
+    def method_missing(meth, *args, &block)
+      if connection.respond_to?(meth)
+        method_retry(meth, *args, &block)
+      else
+        super
+      end
+    end
+
+    def method_retry(method, *args, &block)
+      tries ||= RETRIES + 1
+      connection.send(method, *args, &block)
+    rescue PG::ConnectionBad, PG::AdminShutdown
+      if (tries -= 1) > 0
+        reconnect
+        retry
+      end
+      raise
+    end
+
+    def exec(*args)
+      method_retry(:exec, *args)
+    end
+
+    def exec_params(*args)
+      method_retry(:exec_params, *args)
+    end
+  end
+end

data/lib/hugg_orm/persistence.rb

@@ -0,0 +1,204 @@
+module HuggORM
+  module Persistence
+    include Comparable
+
+    def self.included(base)
+      base.send(:include, InstanceMethods)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      attr_accessor :_table_name, :_primary_key, :_key_field, :_exclude_fields, :_include_fields
+
+      def table_name(table_name = nil)
+        self._table_name = table_name unless table_name.nil?
+        self._table_name
+      end
+
+      def primary_key(primary_key = nil)
+        self._primary_key = primary_key unless primary_key.nil?
+        self._primary_key
+      end
+
+      def key_field(key_field = nil)
+        self._key_field = key_field.to_sym unless key_field.nil?
+        self._key_field ||= :id
+      end
+
+      def exclude_fields(*fields)
+        self._exclude_fields = fields unless fields.empty?
+        self._exclude_fields ||= []
+      end
+
+      def include_fields(*fields)
+        self._include_fields = fields unless fields.empty?
+        self._include_fields ||= []
+      end
+
+      def find(id)
+        where("#{primary_key} = ?", [id]).select.first
+      end
+
+      def all
+        results = new_query.select
+        new_collection(results)
+      end
+
+      def select(query = nil, where: nil, order: nil, limit: nil, offset: nil)
+        return new_collection(query.select) if query
+
+        query = new_query
+        query.where(where[:conditions], where[:values]) if where
+        query.order(order) if order
+        query.limit(limit) if limit
+        query.offset(offset) if offset
+
+        new_collection(query.select)
+      end
+
+      def create(data)
+        new(data) if new_query.insert(data) > 0
+      end
+
+      def update(id, data)
+        results = where("#{primary_key} = ?", [id]).update(data, true)
+        new(results.first) unless results.empty?
+      end
+
+      def destroy(id)
+        where("#{primary_key} = ?", [id]).delete > 0
+      end
+
+      def count
+        new_query.count
+      end
+
+      def where(conditions, values = [])
+        new_query.where(conditions, values)
+      end
+
+      def limit(limit, offset = nil)
+        new_query.limit(limit, offset)
+      end
+
+      def order(*args)
+        new_query.order(*args)
+      end
+
+      def new_query
+        Query.new(table_name)
+      end
+
+      def new_collection(data_ary)
+        data_ary.map { |data| new(data) }
+      end
+
+      def to_pgtimestamp(field)
+        "to_timestamp(#{field}, 'YYYY-MM-DD HH24:MI:SS')"
+      end
+
+      def string_to_pgtimestamp(string)
+        to_pgtimestamp("'#{string}'")
+      end
+
+      def escape_like(str = '')
+        pat = Regexp.union("\\", "%", "_")
+        str.gsub(pat) { |mat| ["\\", mat].join }
+      end
+
+    end
+
+    module InstanceMethods
+      attr_accessor :uuid, :data
+
+      def initialize(data = {})
+        @data = {}
+        update_attributes(data) unless data.empty?
+      end
+
+      def key
+        @data[self.class.key_field]
+      end
+
+      def set_id
+        # Set id based on key field, but only if id isn't already set and
+        # the key method has been overridden and returns data.
+        @data[self.class.key_field] = key if @data[self.class.key_field].nil? && key
+      end
+
+      def update_attributes(update_data)
+        # Remove fields not set to be included
+        unless self.class.include_fields.empty?
+          update_data = self.class.include_fields.each_with_object({}) do |key, hash|
+            hash[key] = update_data[key] if update_data.has_key? key
+          end
+        end
+
+        # Update all fields unless they have been excluded
+        update_data.each do |field, value|
+          @data[field] = value unless self.class.exclude_fields.include?(field)
+        end
+
+        # Set id based on key method.
+        set_id
+
+        self
+      end
+
+      def destroy
+        if self.class.destroy(key)
+          @data = {}
+          @state = :destroyed
+        end
+
+        self
+      end
+
+      def save
+        updated_data = self.class.where("#{self.class.primary_key} = ?", [key]).update(@data, true)
+
+        if updated_data != 0
+          @data = updated_data
+          @state = :updated
+        else
+          self.class.new_query.insert(@data)
+          @state = :created
+        end
+
+        self
+      end
+
+      def destroyed?
+        @state == :destroyed
+      end
+
+      def updated?
+        @state == :updated
+      end
+
+      def created?
+        @state == :created
+      end
+
+      def dump
+        str = "#{self.class.name}:\n"
+        @data.sort.each do |field, value|
+          str << "  #{field}: #{value}\n"
+        end
+        str
+      end
+
+      def fetch(*args)
+        @data.send(:fetch, *args)
+      end
+
+      def has_field?(field)
+        @data.has_key?(field)
+      end
+
+      def <=>(o)
+        o.kind_of?(self.class) && @data == o.data ? 0 : nil
+      end
+    end
+  end
+end

data/lib/hugg_orm/query.rb

@@ -0,0 +1,98 @@
+module HuggORM
+  class Query
+    attr_reader :table, :column_name, :values,
+                :_command, :_where, :_order, :_limit, :_offset, :_returning
+
+    def initialize(table, column_name = 'data')
+      @table = table
+      @column_name = column_name
+      @values = []
+    end
+
+    def run
+      HuggORM::Connection.db.exec_params(to_sql, @values)
+    end
+
+    def to_sql
+      sql = "#{@_command} #{@_where} #{@_order} #{@_limit} #{@_offset} #{@_returning}".strip
+      sql.gsub!(/\s{2,}/, ' ')
+      sql
+    end
+
+    def insert(data)
+      @_command = "INSERT INTO #{@table} (#{@column_name}) VALUES (#{next_placeholder})"
+      @values << data.to_json
+      pg_result = run
+      pg_result.cmd_tuples
+    end
+
+    def update(data, return_data = false)
+      @_command = "UPDATE #{@table} SET #{@column_name} = #{@column_name} || #{next_placeholder}::jsonb"
+      @values << data.to_json
+
+      if return_data
+        @_returning = "RETURNING #{@column_name}"
+        return run.map { |tuple| deserialize(tuple["#{@column_name}"]) }
+      end
+
+      run.cmd_tuples
+    end
+
+    def select
+      @_command = "SELECT #{@column_name} FROM #{@table}"
+      pg_result = run
+      pg_result.map { |tuple| deserialize(tuple["#{@column_name}"]) }
+    end
+
+    def delete
+      @_command = "DELETE FROM #{@table}"
+      run.cmd_tuples
+    end
+
+    def count
+      @_command = "SELECT COUNT(*) FROM #{@table}"
+      run.getvalue(0, 0).to_i
+    end
+
+    def where(conditions, values = [])
+      values.size.times { |i| conditions.sub!(/\?/, next_placeholder(i + 1)) }
+      @_where = "WHERE #{conditions}"
+      @values += values
+      self
+    end
+
+    def limit(limit, offset = nil)
+      @_limit = "LIMIT #{next_placeholder}"
+      @values << limit
+      self.offset(offset) if offset
+      self
+    end
+
+    def offset(offset)
+      @_offset = "OFFSET #{next_placeholder}"
+      @values << offset
+      self
+    end
+
+    def order(*args)
+      fields = []
+      args.first.each_pair { |field, order| fields << "#{wrap_json(field)} #{order}" }
+      @_order = "ORDER BY #{fields.join(', ')}"
+      self
+    end
+
+    private
+
+    def deserialize(data)
+      JSON.parse(data, symbolize_names: true)
+    end
+
+    def next_placeholder(offset = 1)
+      "$#{@values.size + offset}"
+    end
+
+    def wrap_json(field)
+      "#{@column_name}->>'#{field}'"
+    end
+  end
+end

data/lib/hugg_orm/version.rb

@@ -0,0 +1,3 @@
+module HuggORM
+  VERSION = "1.0.0"
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: hugg-orm
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Olle Johansson
+- Lúcio Rosa
+- Avidity
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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'
+description: Ruby Object Relational Mapper for JSON-based models with PostgreSQL
+email:
+- code@avidity.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hugg_orm.rb
+- lib/hugg_orm/connection.rb
+- lib/hugg_orm/persistence.rb
+- lib/hugg_orm/query.rb
+- lib/hugg_orm/version.rb
+homepage: https://github.com/avidity/hugg-orm
+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: Ruby ORM for Postgresql
+test_files: []