static-record 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5b162063f35ae54889eb3667e905da0e9ded7006
-  data.tar.gz: 47cb368f415b140fd8a1edfb0d0871ee557028d1
+  metadata.gz: 7da53ed48dde6c544df166fad92cba19ba41114a
+  data.tar.gz: eb494a5eab6d82746d0654fcddc20b2d5d6cfc8c
 SHA512:
-  metadata.gz: 2818d1563d8abb371273626a852150de43df729fd2aa8db28229b56f060115ed43e98a381e7df716c8a832c25fb23357807ea69fabf47f2741c20615d485c000
-  data.tar.gz: df9d29e83a7d6ba39386710e17857790355667c85c04be06e9b0be4bea8dd8084d13fcd1ab6e4115de1e9e55c9c36ca3c460849af01fcf657c3a1282b245b20d
+  metadata.gz: eec734004a50419ddedfd06c5d8c44432f73ac58cc7e3280407ce95ce775a559d9e98ae2ec618d04293c58dfb15afa3ad5a8efd80a5147e62f5900750d228eb4
+  data.tar.gz: ebee3f534fc292c7f80c9f0d7e0f80aca269f4e02e336198670665d0468c7f628e8fdea2ebd39021d871d4da36dc302f4727c861c41e13d8641ebb2f59b9c0e2

data/lib/static_record.rb

@@ -4,14 +4,26 @@ require 'static_record/exceptions'
 require 'static_record/concerns/query_building_concern'
 require 'static_record/concerns/sqlite_storing_concern'
 
-require 'static_record/models/predicates'
+require 'static_record/models/query_interface/conditioners'
+require 'static_record/models/query_interface/retrievers'
+require 'static_record/models/query_interface/search_modifiers'
+require 'static_record/models/query_interface/sql_helpers'
+require 'static_record/models/query_interface'
+
 require 'static_record/models/querying'
 require 'static_record/models/relation'
 require 'static_record/models/base'
 
-require 'static_record/migrations/schema'
-require 'static_record/migrations/railtie'
 require 'static_record/migrations/has_static_record'
 
-module StaticRecord # :nodoc:
+# This ClassMethods module will be extended by ActiveRecord
+module StaticRecord
+  module ClassMethods # :nodoc:
+    def has_static_record(name, options = nil)
+      HasStaticRecord.define_on(self, name, options || {})
+    end
+  end
 end
+
+require 'static_record/migrations/schema'
+require 'static_record/migrations/railtie'

data/lib/static_record/concerns/sqlite_storing_concern.rb

@@ -45,6 +45,10 @@ module StaticRecord
       end
 
       def insert_into_database(db, record, index, cols)
+        # TODO: get attributes without instantiating the record
+        # that currently forces to declare base file (ex: badge.rb) columns
+        # at the end of file, without what Badge instance methods are not defined
+        # yet during BadgeOne#initialize
         attrs = record.constantize.new.attributes
         # id, klass
         sqlized = [index.to_s, "'#{record}'"]

data/lib/static_record/migrations/has_static_record.rb

@@ -1,52 +1,55 @@
 module StaticRecord
   # Provides has_static_record when included
-  module HasStaticRecord
-    def self.included(base)
-      base.extend(ClassMethods)
+  class HasStaticRecord
+    def self.define_on(klass, name, options)
+      new(klass, name, options).define
     end
 
-    module ClassMethods # :nodoc:
-      def has_static_record(table_name, options = nil)
-        options ||= {}
-        class_eval do
-          define_setter(table_name, options)
-          define_getter(table_name, options)
-        end
-      end
-
-      private
+    def initialize(klass, name, options)
+      @klass = klass
+      @name = name
+      @options = options
+    end
 
-      def define_setter(table_name, options)
-        define_method("#{table_name}=") do |static_record|
-          table = __method__.to_s.delete('=')
-          options[:class_name] ||= table.camelize
-          superklass = static_record.class.superclass
+    def define
+      define_getter
+      define_setter
+    end
 
-          unless superklass.to_s == options[:class_name]
-            err = "Record must be an instance of #{options[:class_name]}, got #{superklass}"
-            raise ClassError, err
-          end
+    private
 
-          unless superklass.pkey
-            err = "No primary key has been defined for #{superklass.class}"
-            raise NoPrimaryKey, err
-          end
+    def define_getter
+      name = @name
+      options = @options
+      @klass.send :define_method, @name do
+        record_type = send(:"#{name}_static_record_type")
+        return nil unless record_type
 
-          send(:"#{table}_static_record_type=", static_record.class.name)
-        end
+        options[:class_name] ||= name.to_s.camelize
+        # eager loading may be disabled, initialize parent class
+        superklass = options[:class_name].constantize
+        superklass.find_by(klass: record_type)
       end
+    end
 
-      def define_getter(table_name, options)
-        define_method(table_name) do
-          table = __method__.to_s
-          record_type = send(:"#{table}_static_record_type")
-          return nil unless record_type
+    def define_setter
+      name = @name
+      options = @options
+      @klass.send :define_method, "#{@name}=" do |static_record|
+        options[:class_name] ||= name.to_s.camelize
+        superklass = static_record.class.superclass
 
-          options[:class_name] ||= table.camelize
-          # eager loading may be disabled, initialize parent class
-          superklass = options[:class_name].constantize
-          superklass.find_by(klass: record_type)
+        unless superklass.to_s == options[:class_name]
+          err = "Record must be an instance of #{options[:class_name]}, got #{superklass}"
+          raise ClassError, err
         end
+
+        unless superklass.pkey
+          err = "No primary key has been defined for #{superklass.class}"
+          raise NoPrimaryKey, err
+        end
+
+        send(:"#{name}_static_record_type=", static_record.class.name)
       end
     end
   end

data/lib/static_record/migrations/railtie.rb

@@ -2,14 +2,9 @@ module StaticRecord
   class Railtie < Rails::Railtie # :nodoc:
     initializer 'static_record.insert_into_active_record' do |_app|
       ActiveSupport.on_load :active_record do
-        StaticRecord::Railtie.insert
-      end
-    end
-
-    def self.insert
-      if defined?(ActiveRecord)
-        ActiveRecord::Base.send(:include, StaticRecord::Schema)
-        ActiveRecord::Base.send(:include, StaticRecord::HasStaticRecord)
+        send(:extend, StaticRecord::ClassMethods)
+        send(:include, StaticRecord::Schema)
+        ActiveSupport.run_load_hooks(:static_record, StaticRecord::Base)
       end
     end
   end

data/lib/static_record/models/query_interface.rb

@@ -0,0 +1,11 @@
+module StaticRecord
+  # Contains ActiveRecord-like query interface methods
+  module QueryInterface
+    module Interface # :nodoc:
+      include StaticRecord::QueryInterface::Conditioners
+      include StaticRecord::QueryInterface::Retrievers
+      include StaticRecord::QueryInterface::SearchModifiers
+      include StaticRecord::QueryInterface::SqlHelpers
+    end
+  end
+end

data/lib/static_record/models/query_interface/conditioners.rb

@@ -0,0 +1,28 @@
+module StaticRecord
+  # Contains ActiveRecord-like query interface methods
+  module QueryInterface
+    # Contains conditioners
+    module Conditioners
+      private
+
+      def where(query = nil, *params)
+        params = [params] unless params.is_a?(Array) || params.is_a?(Hash)
+        params = params.first if params.size == 1 && params[0].is_a?(Hash)
+        add_subclause({ q: query }, params) if query
+        self
+      end
+
+      def not(query, *params)
+        params = [params] unless params.is_a?(Array) || params.is_a?(Hash)
+        params = params.first if params.size == 1 && params[0].is_a?(Hash)
+        add_subclause({ q: query, operator: :not_eq }, params)
+        self
+      end
+
+      def or
+        @chain = :or
+        self
+      end
+    end
+  end
+end

data/lib/static_record/models/query_interface/retrievers.rb

@@ -0,0 +1,75 @@
+module StaticRecord
+  # Contains ActiveRecord-like query interface methods
+  module QueryInterface
+    # Contains retrievers
+    module Retrievers
+      private
+
+      def to_a
+        exec_request
+      end
+
+      def all
+        to_a
+      end
+
+      def find(value)
+        raise StaticRecord::NoPrimaryKey, 'No primary key have been set' if @primary_key.nil?
+        unless value.is_a?(Array)
+          @result_type = :record
+          @sql_limit = 1
+        end
+        add_subclause(q: { :"#{@primary_key}" => value })
+        res = to_a
+
+        unless @only_sql
+          case @result_type
+          when :array
+            if res.size != value.size
+              err = "Couldn't find all #{@store.singularize.capitalize} "\
+              "with '#{@primary_key}' IN #{value}"
+              raise StaticRecord::RecordNotFound, err
+            end
+          when :record
+            if res.nil?
+              err = "Couldn't find #{@store.singularize.capitalize} "\
+              "with '#{@primary_key}'=#{value}"
+              raise StaticRecord::RecordNotFound, err
+            end
+          end
+        end
+
+        res
+      end
+
+      def find_by(query)
+        add_subclause(q: query)
+        take(1)
+      end
+
+      def take(amount = 1)
+        @sql_limit = amount
+        @result_type = :record if amount == 1
+        to_a
+      end
+
+      def first(amount = 1)
+        @order_by << { :"#{@primary_key}" => :asc } if @primary_key && @order_by.empty?
+        take(amount)
+      end
+
+      def last(amount = 1)
+        if !@primary_key && @order_by.empty?
+          cnt = self.class.new(self, store: @store, primary_key: @primary_key).no_sql.send(:count)
+          @sql_offset = [cnt - amount, 0].max
+          res = take(amount)
+        else
+          @order_by << { :"#{@primary_key}" => :desc } if @order_by.empty?
+          res = take(amount)
+          res.reverse! if res.is_a?(Array)
+        end
+        res
+      end
+    end
+  end
+end

data/lib/static_record/models/query_interface/search_modifiers.rb

@@ -0,0 +1,29 @@
+module StaticRecord
+  # Contains ActiveRecord-like query interface methods
+  module QueryInterface
+    # Contains search modifiers
+    module SearchModifiers
+      private
+    
+      def limit(amount)
+        @sql_limit = amount
+        self
+      end
+
+      def offset(amount)
+        @sql_offset = amount
+        self
+      end
+
+      def order(ord)
+        @order_by << ord
+        self
+      end
+
+      def count
+        @columns = 'COUNT(*)'
+        exec_request(:integer)
+      end
+    end
+  end
+end

data/lib/static_record/models/query_interface/sql_helpers.rb

@@ -0,0 +1,23 @@
+module StaticRecord
+  # Contains ActiveRecord-like query interface methods
+  module QueryInterface
+    # Contains SQL helpers
+    module SqlHelpers
+      private
+
+      def to_sql
+        build_query
+      end
+
+      def see_sql_of
+        @only_sql = true
+        self
+      end
+
+      def no_sql
+        @only_sql = false
+        self
+      end
+    end
+  end
+end

data/lib/static_record/models/relation.rb

@@ -9,7 +9,7 @@ module StaticRecord
                 :order_by,
                 :only_sql
 
-    include Predicates
+    include StaticRecord::QueryInterface::Interface
     include StaticRecord::QueryBuildingConcern
 
     def initialize(previous_node, params)

data/lib/static_record/version.rb

@@ -1,3 +1,3 @@
 module StaticRecord
-  VERSION = '1.0.0'.freeze
+  VERSION = '1.0.1'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: static-record
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Hugo Chevalier
@@ -152,7 +152,11 @@ files:
 - lib/static_record/migrations/railtie.rb
 - lib/static_record/migrations/schema.rb
 - lib/static_record/models/base.rb
-- lib/static_record/models/predicates.rb
+- lib/static_record/models/query_interface.rb
+- lib/static_record/models/query_interface/conditioners.rb
+- lib/static_record/models/query_interface/retrievers.rb
+- lib/static_record/models/query_interface/search_modifiers.rb
+- lib/static_record/models/query_interface/sql_helpers.rb
 - lib/static_record/models/querying.rb
 - lib/static_record/models/relation.rb
 - lib/static_record/version.rb

data/lib/static_record/models/predicates.rb

@@ -1,125 +0,0 @@
-module StaticRecord
-  # Contains ActiveRecord-like query predicates
-  module Predicates
-    private
-
-    def where(query = nil, *params)
-      params = [params] unless params.is_a?(Array) || params.is_a?(Hash)
-      params = params.first if params.size == 1 && params[0].is_a?(Hash)
-      add_subclause({ q: query }, params) if query
-      self
-    end
-
-    def not(query, *params)
-      params = [params] unless params.is_a?(Array) || params.is_a?(Hash)
-      params = params.first if params.size == 1 && params[0].is_a?(Hash)
-      add_subclause({ q: query, operator: :not_eq }, params)
-      self
-    end
-
-    def or
-      @chain = :or
-      self
-    end
-
-    def all
-      to_a
-    end
-
-    def find(value)
-      raise StaticRecord::NoPrimaryKey, 'No primary key have been set' if @primary_key.nil?
-      unless value.is_a?(Array)
-        @result_type = :record
-        @sql_limit = 1
-      end
-      add_subclause(q: { :"#{@primary_key}" => value })
-      res = to_a
-
-      unless @only_sql
-        case @result_type
-        when :array
-          if res.size != value.size
-            err = "Couldn't find all #{@store.singularize.capitalize} "\
-            "with '#{@primary_key}' IN #{value}"
-            raise StaticRecord::RecordNotFound, err
-          end
-        when :record
-          if res.nil?
-            err = "Couldn't find #{@store.singularize.capitalize} "\
-            "with '#{@primary_key}'=#{value}"
-            raise StaticRecord::RecordNotFound, err
-          end
-        end
-      end
-
-      res
-    end
-
-    def find_by(query)
-      add_subclause(q: query)
-      take(1)
-    end
-
-    def take(amount = 1)
-      @sql_limit = amount
-      @result_type = :record if amount == 1
-      to_a
-    end
-
-    def first(amount = 1)
-      @order_by << { :"#{@primary_key}" => :asc } if @primary_key && @order_by.empty?
-      take(amount)
-    end
-
-    def last(amount = 1)
-      if !@primary_key && @order_by.empty?
-        cnt = self.class.new(self, store: @store, primary_key: @primary_key).no_sql.send(:count)
-        @sql_offset = [cnt - amount, 0].max
-        res = take(amount)
-      else
-        @order_by << { :"#{@primary_key}" => :desc } if @order_by.empty?
-        res = take(amount)
-        res.reverse! if res.is_a?(Array)
-      end
-      res
-    end
-
-    def limit(amount)
-      @sql_limit = amount
-      self
-    end
-
-    def offset(amount)
-      @sql_offset = amount
-      self
-    end
-
-    def order(ord)
-      @order_by << ord
-      self
-    end
-
-    def count
-      @columns = 'COUNT(*)'
-      exec_request(:integer)
-    end
-
-    def to_sql
-      build_query
-    end
-
-    def see_sql_of
-      @only_sql = true
-      self
-    end
-
-    def no_sql
-      @only_sql = false
-      self
-    end
-
-    def to_a
-      exec_request
-    end
-  end
-end