active_shotgun 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1e2345b2533af34895ef3e5ba10ab8c161f24ad36edb318d4e101747dddeb9e
-  data.tar.gz: 39e87e5dfc26b9697094d2b826518ac9fa9a6021e24dcab684b56f08989720b1
+  metadata.gz: 611b243c8abdc485ee5fe5b8b1bf86fa393a0d782a568081e78991c5bd42546f
+  data.tar.gz: b121ffffa365bcc386d0009722692f5a9cb5162bc874c229b154e1b92bb4ddb4
 SHA512:
-  metadata.gz: c37bf9627795d8a13f32755a0120fbe28b521b35d242e99727f3e15ceb9150b80928361f699ac4481d3f7424dea5418864e1852b957dc7285d6402d4f6f2139d
-  data.tar.gz: 2e949a1793fcd76a7cbf16fa894b9d23f5fe07eae3feaa0a035cddde61e38da69d102076df29935fd4b9b64dbc3859241e60f66a8e14cce3476424eb00e51190
+  metadata.gz: f6e8be7c026a4d694a17fb825b4c24a0ff91c9a5f6eb958b30dd6b5f8ecc2f6f94cdf4fd6d6a6fbfb4892b68bc8ce926f64730d17d04013d0b14e063b64275d1
+  data.tar.gz: 78a61e5073d3e913e5382086c095320ca3efe4cf3ff6cd79ea6a9ffd7116ead4a8e793e563302c3165b8190b47e031e3be4f72a852247534f15c66b223d77765

data/.rubocop.yml

@@ -17,6 +17,9 @@ AllCops:
 Naming/FileName:
   Enabled: false
 
+Naming/PredicateName:
+  Enabled: false
+
 Gemspec/RequiredRubyVersion:
   Enabled: false
 

data/CHANGELOG.md

@@ -6,6 +6,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.4] - 2020-12-17
+### Added
+- count and size
+- support for belongs_to and has_many
+
 ## [0.0.3] - 2020-12-16
 ### Added
 - First version of AR complient queries. Supports:
@@ -42,7 +47,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Gem init
 
-[Unreleased]: https://github.com/zaratan/active_shotgun/compare/v0.0.3...HEAD
+[Unreleased]: https://github.com/zaratan/active_shotgun/compare/v0.0.4...HEAD
+[0.0.4]: https://github.com/zaratan/active_shotgun/releases/tag/v0.0.4
 [0.0.3]: https://github.com/zaratan/active_shotgun/releases/tag/v0.0.3
 [0.0.2.1]: https://github.com/zaratan/active_shotgun/releases/tag/v0.0.2.1
 [0.0.2]: https://github.com/zaratan/active_shotgun/releases/tag/v0.0.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    active_shotgun (0.0.3)
+    active_shotgun (0.0.4)
       activemodel (>= 5.2)
       shotgun_api_ruby (>= 0.0.8.2)
       zeitwerk (~> 2)
@@ -100,7 +100,7 @@ GEM
       simplecov (>= 0.4.1)
     simplecov_json_formatter (0.1.2)
     thor (1.0.1)
-    tzinfo (2.0.3)
+    tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (1.7.0)
     yard (0.9.25)

data/lib/active_shotgun/associations_proxy.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module ActiveShotgun
+  class AssociationsProxy
+    def initialize(base_class:, base_id:, field_name:, possible_types: {})
+      @base_class = base_class
+      @base_id = base_id
+      @field_name = field_name
+      @possible_types = possible_types
+      @queries =
+        possible_types.map do |type, klass|
+          Query.new(type: type, klass: klass)
+        end
+      @global_limit = 1000
+      @global_offset = 0
+      @global_orders = nil
+      @global_fields = nil
+    end
+
+    def push(model)
+      already_here =
+        @queries.reduce([]) do |result, query|
+          result + query.dup.limit(1000).pluck(:id).map{ |id|
+                     { type: query.instance_variable_get(:@type), id: id }
+                   }
+        end
+      Client.shotgun.entities(@base_class.to_s).update(
+        @base_id,
+        @field_name => already_here.push(
+          {
+            type: model.class.shotgun_type,
+            id: model.id,
+          }
+        ).uniq
+      )
+      @array = nil
+      true
+    end
+    alias_method :<<, :push
+
+    def delete(id, type = nil)
+      raise "Many types possible. Please specify." if !type && has_many_types?
+
+      type ||= @possible_types.keys.first
+      already_here =
+        @queries.reduce([]) do |result, query|
+          result + query.dup.limit(1000).pluck(:id).map{ |item_id|
+                     { type: query.instance_variable_get(:@type), id: item_id }
+                   }
+        end
+      new_items = already_here.reject{ |item| item[:type] == type && item[:id] == id }
+
+      Client.shotgun.entities(@base_class.to_s).update(
+        @base_id,
+        @field_name => new_items.uniq
+      )
+      @array = nil
+      true
+    end
+
+    def has_many_types?
+      @has_many_types ||= @queries.size > 1
+    end
+
+    def all
+      @array ||= resolve_all_queries # rubocop:disable Naming/MemoizedInstanceVariableName
+    end
+    alias_method :to_a, :all
+
+    def first(number = 1)
+      results = limit(number).all
+      if @global_limit == 1
+        results.first
+      else
+        results
+      end
+    end
+
+    def limit(number)
+      @global_limit = number
+      @queries =
+        @queries.map do |query|
+          has_many_types? ? query.limit(1000) : query.limit(number)
+        end
+      self
+    end
+
+    def offset(number)
+      @global_offset = number
+      @queries =
+        @queries.map do |query|
+          has_many_types? ? query : query.offset(number)
+        end
+      @array = nil
+      self
+    end
+
+    def where(conditions)
+      @queries =
+        @queries.map do |query|
+          query.where(conditions)
+        end
+      @array = nil
+      self
+    end
+
+    def find_by(conditions)
+      where(conditions).first
+    end
+
+    def orders(new_orders)
+      @global_orders = new_orders
+      @queries =
+        @queries.map do |query|
+          query.orders(new_orders)
+        end
+      @array = nil
+      self
+    end
+
+    def select(*fields)
+      @queries =
+        @queries.map do |query|
+          query.select(fields)
+        end
+      @array = nil
+      self
+    end
+
+    def pluck(*fields)
+      fields.flatten!
+      result = select(fields).map{ |e| fields.map{ |field| e.public_send(field) } }
+      fields.size == 1 ? result.flatten : result
+    end
+
+    extend Forwardable
+    def_delegators(
+      :all,
+      :each,
+      :size,
+      :count
+    )
+    include Enumerable
+
+    private
+
+    def global_orders_to_h
+      case @global_orders
+      when Hash # rubocop:disable Lint/EmptyWhen
+      when Array
+        @global_orders.map do |str|
+          [str.gsub(/^[-+]/, '').to_sym, str.start_with?('-') ? :desc : :asc]
+        end
+      when String
+        @global_orders = @global_orders.split(/\s*,\s*/)
+        global_orders_to_h
+      else
+        raise "Unknown order type"
+      end
+    end
+
+    def sort_results(results)
+      orders = global_orders_to_h
+      results.sort do |a, b|
+        orders.reduce(0) do |res, order|
+          if res == 0
+            field = order.first
+            if order.last == :asc
+              a.public_send(field) <=> b.public_send(field)
+            else
+              b.public_send(field) <=> a.public_send(field)
+            end
+          else
+            res
+          end
+        end
+      end
+    end
+
+    def resolve_all_queries
+      if has_many_types?
+        results = @queries.flat_map(&:to_a)
+        results = sort_results(results)
+        results.shift(@global_offset).first(@global_limit)
+      else
+        @queries.flat_map(&:to_a)
+      end
+    end
+  end
+end

data/lib/active_shotgun/model.rb

@@ -58,6 +58,8 @@ module ActiveShotgun
       base_class.extend(Delete::ClassMethods)
       base_class.prepend(Validations)
       base_class.prepend(Callbacks)
+      base_class.include(Associations)
+      base_class.extend(Associations::ClassMethods)
     end
   end
 end

data/lib/active_shotgun/model/associations.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ActiveShotgun
+  module Model
+    module Associations
+      def self.included(base_class)
+        base_class.const_set(:BELONG_ASSOC, [])
+        base_class.const_set(:MANY_ASSOC, [])
+      end
+
+      module ClassMethods
+        def belongs_to(assoc_name, klass: nil, types: nil, type: nil)
+          klass ||= assoc_name.to_s.camelize
+          types ||= [type].flatten if type
+          types ||= [assoc_name.to_s.camelize]
+          types = [types].flatten.map(&:to_s)
+          # define name_id
+          # define name that read and populate the class
+          instance_eval do
+            # Register the association
+            self::BELONG_ASSOC.push(assoc_name)
+
+            # Define the id reader
+            attr_reader "#{assoc_name}_id"
+
+            # Define the id writter
+            define_attribute_methods("#{assoc_name}_id")
+            define_method("#{assoc_name}_id=") do |value, new_type = nil|
+              send("#{assoc_name}_id_will_change!")
+              if new_type
+                unless types.include?(new_type)
+                  raise "Invalid Type #{new_type}. Valid types are: [#{types.join(', ')}]"
+                end
+
+                instance_variable_set("@#{assoc_name}_type", new_type)
+              elsif types.size == 1
+                instance_variable_set("@#{assoc_name}_type", types.first)
+              else
+                unless public_send("#{assoc_name}_type")
+                  raise "Multiple types possible. You must specify a type from [#{types.join(', ')}]"
+                end
+              end
+              instance_variable_set("@#{assoc_name}_id", value)
+            end
+
+            # Define the type reader
+            attr_reader "#{assoc_name}_type"
+
+            # Define the assoc reader
+            define_method(assoc_name) do
+              instance_variable_get("@#{assoc_name}") ||
+                instance_variable_set(
+                  "@#{assoc_name}",
+                  (klass.is_a?(String) ? klass.constantize : klass).
+                  parse_shotgun_results(
+                    Client.
+                    shotgun.
+                    entities(public_send("#{assoc_name}_type")).
+                    find(public_send("#{assoc_name}_id"))
+                  )
+                )
+            end
+
+            define_method("#{assoc_name}=") do |assoc_item|
+              public_send("#{assoc_name}_id=", assoc_item.id, assoc_item.class.shotgun_type)
+              instance_variable_set("@#{assoc_name}", assoc_item)
+            end
+          end
+        end
+
+        def has_many(assoc_name_plural, possible_types: nil)
+          assoc_name = assoc_name_plural.to_s.singularize
+          possible_types ||= {
+            assoc_name.camelize => assoc_name.camelize,
+          }
+          if possible_types.is_a?(Array)
+            possible_types.map do |type|
+              [
+                type.camelize,
+                type.camelize,
+              ]
+            end.to_h
+          end
+          # define name that read and populate an array of (a query ?)
+
+          instance_eval do
+            # Register the association
+            self::MANY_ASSOC.push(assoc_name_plural)
+
+            # Define reader must return an AssociationQuery which override push/<</delete with instant remove/add
+            define_method(assoc_name_plural) do
+              instance_variable_get("@#{assoc_name_plural}") ||
+                instance_variable_set(
+                  "@#{assoc_name_plural}",
+                  AssociationsProxy.new(
+                    possible_types: possible_types,
+                    base_class: self.class,
+                    base_id: id,
+                    field_name: assoc_name_plural
+                  ).where(
+                    [
+                      self.class.shotgun_type.downcase.to_s.pluralize,
+                      "is",
+                      {
+                        type: self.class.shotgun_type.camelize,
+                        id: id,
+                      },
+                    ]
+                  )
+                )
+            end
+
+            # Define writer
+            define_attribute_methods(assoc_name_plural)
+            define_method("#{assoc_name_plural}=") do |array|
+              send("#{assoc_name_plural}_will_change!")
+              instance_variable_set("@#{assoc_name_plural}", array)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_shotgun/model/read.rb

@@ -15,10 +15,17 @@ module ActiveShotgun
         end.to_h
       end
 
-      def initialize(new_attributes = {})
+      def initialize(new_attributes = {}, new_relations = {})
         new_attributes.slice(*self.class.shotgun_readable_fetched_attributes).each do |attribute, value|
           instance_variable_set("@#{attribute}", value)
         end
+        self.class::BELONG_ASSOC.each do |assoc|
+          next unless relation = new_relations[assoc]
+
+          instance_variable_set("@#{assoc}_type", relation["type"])
+          instance_variable_set("@#{assoc}_id", relation["id"])
+          instance_variable_set("@#{assoc}", nil)
+        end
       end
 
       def reload
@@ -60,7 +67,22 @@ module ActiveShotgun
 
         def find(id)
           sg_result = shotgun_client.find(id)
-          new(sg_result.attributes.to_h.merge(id: sg_result.id))
+          parse_shotgun_results(sg_result)
+        end
+
+        def count
+          prepare_new_query.count
+        end
+
+        def size
+          prepare_new_query.size
+        end
+
+        def parse_shotgun_results(sg_result)
+          new(
+            sg_result.attributes.to_h.merge(id: sg_result.id),
+            sg_result.relationships.transform_values{ |v| v["data"] }.with_indifferent_access
+          )
         end
       end
     end

data/lib/active_shotgun/model/write.rb

@@ -12,23 +12,35 @@ module ActiveShotgun
 
         sg_result =
           if persisted?
-            shotgun_client.update(id, changes.transform_values(&:last))
+            shotgun_client.update(id, changes_with_relations)
           else
-            shotgun_client.create(changes.transform_values(&:last))
+            shotgun_client.create(changes_with_relations)
           end
-        override_attributes!(sg_result.attributes.to_h.merge(id: sg_result.id))
+        override_attributes!(sg_result)
         changes_applied
         true
       end
       alias_method :save!, :save
 
       def mass_assign(assigned_attributes)
-        assigned_attributes.
-          transform_keys(&:to_sym).
+        sym_assigned_attributes = assigned_attributes.transform_keys(&:to_sym)
+        sym_assigned_attributes.
           slice(*self.class.shotgun_writable_fetched_attributes).
           each do |k, v|
             public_send("#{k}=", v)
           end
+
+        sym_assigned_attributes.
+          slice(*self.class::BELONG_ASSOC.map{ |assoc| "#{assoc}_id".to_sym }).
+          each do |k, v|
+            public_send("#{k}=", v, sym_assigned_attributes["#{k.to_s.gsub(/_id$/, '')}_type".to_sym])
+          end
+
+        sym_assigned_attributes.
+          slice(*self.class::BELONG_ASSOC.map(&:to_sym)).
+          each do |k, v|
+            public_send("#{k}=", v)
+          end
       end
 
       def update(updated_attributes)
@@ -46,24 +58,49 @@ module ActiveShotgun
           new_entity = new
           new_entity.mass_assign(create_attributes)
           new_entity.save
+          new_entity
         end
 
         def create!(create_attributes)
           new_entity = new
           new_entity.mass_assign(create_attributes)
           new_entity.save!
+          new_entity
         end
       end
 
       private
 
-      def override_attributes!(new_attributes)
+      def changes_with_relations
+        attribute_changes = changes.slice(*self.class.shotgun_writable_fetched_attributes).transform_values(&:last)
+
+        belongs_to_changes = changes.slice(*self.class::BELONG_ASSOC.map{ |assoc| "#{assoc}_id" }).map do |k, _v|
+          raw = k.gsub(/_id$/, '')
+          [
+            raw,
+            { id: public_send(k), type: public_send("#{raw}_type") },
+          ]
+        end.to_h
+        attribute_changes.merge(belongs_to_changes)
+      end
+
+      def override_attributes!(sg_result)
+        new_attributes = sg_result.attributes.to_h.merge(id: sg_result.id)
         new_attributes.
           transform_keys(&:to_sym).
           slice(*self.class.shotgun_readable_fetched_attributes).
           each do |k, v|
             instance_variable_set("@#{k}", v)
           end
+
+        new_relations = sg_result.relationships.transform_values{ |v| v["data"] }.with_indifferent_access
+        self.class::BELONG_ASSOC.each do |assoc|
+          next unless relation = new_relations[assoc]
+
+          instance_variable_set("@#{assoc}_type", relation["type"])
+          instance_variable_set("@#{assoc}_id", relation["id"])
+          instance_variable_set("@#{assoc}", nil)
+        end
       end
     end
   end

data/lib/active_shotgun/query.rb

@@ -4,7 +4,7 @@ module ActiveShotgun
   class Query
     def initialize(type:, klass:)
       @type = type
-      @klass = klass
+      @klass = klass.is_a?(String) ? klass.constantize : klass
       @conditions = nil
       @limit = 100
       @offset = 0
@@ -15,7 +15,9 @@ module ActiveShotgun
     extend Forwardable
     def_delegators(
       :to_a,
-      :each
+      :each,
+      :size,
+      :count
     )
     include Enumerable
 
@@ -31,7 +33,7 @@ module ActiveShotgun
       results.pop(page_calc[:end_trim])
       results.shift(page_calc[:start_trim])
 
-      results.map{ |result| @klass.new(result.attributes.to_h.merge(id: result.id)) }
+      results.map{ |result| @klass.parse_shotgun_results(result) }
     end
     alias_method :to_a, :all
 
@@ -55,7 +57,40 @@ module ActiveShotgun
     end
 
     def where(conditions)
-      @conditions = (@conditions || {}).merge(conditions)
+      @conditions ||= {}
+      @conditions =
+        case conditions
+        when Hash
+          case @conditions
+          when Hash
+            @conditions.merge(conditions)
+          when Array
+            @conditions + translate_hash_contitions_to_array(conditions)
+          else
+            raise "Unknow type. Please use Hash or Array conditions"
+          end
+        when Array
+          case @conditions
+          when Hash
+            translate_hash_contitions_to_array(@conditions) +
+            if conditions.first.is_a? Array
+              conditions
+            else
+              [conditions]
+            end
+          when Array
+            @conditions +
+            if conditions.first.is_a? Array
+              conditions
+            else
+              [conditions]
+            end
+          else
+            raise "Unknow type. Please use Hash or Array conditions"
+          end
+        else
+          @conditions
+        end
       self
     end
 
@@ -81,6 +116,12 @@ module ActiveShotgun
 
     private
 
+    def translate_hash_contitions_to_array(hash_conditions)
+      hash_conditions.map do |k, v|
+        [k, "is", v]
+      end
+    end
+
     def format_page_from_limit_and_offset(limit, offset)
       min = (offset + 1).to_f
       max = (offset + limit).to_f

data/lib/active_shotgun/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveShotgun
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_shotgun
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Denis <Zaratan> Pasin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-12-16 00:00:00.000000000 Z
+date: 2020-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -263,9 +263,11 @@ files:
 - bin/console
 - bin/setup
 - lib/active_shotgun.rb
+- lib/active_shotgun/associations_proxy.rb
 - lib/active_shotgun/client.rb
 - lib/active_shotgun/config.rb
 - lib/active_shotgun/model.rb
+- lib/active_shotgun/model/associations.rb
 - lib/active_shotgun/model/callbacks.rb
 - lib/active_shotgun/model/delete.rb
 - lib/active_shotgun/model/read.rb