datasource 0.1.1 → 0.2.0

data/lib/datasource/attributes/loader.rb

@@ -1,86 +0,0 @@
-module Datasource
-  module Attributes
-    class Loader
-      class << self
-        attr_accessor :_options
-        attr_accessor :_load_proc
-
-        def inherited(base)
-          base._options = (_options || {}).dup
-        end
-
-        def options(hash)
-          self._options.merge!(hash)
-        end
-
-        def default_value
-          self._options[:default]
-        end
-
-        def load(*args, &block)
-          args = args.slice(0, _load_proc.arity) if _load_proc.arity >= 0
-          results = _load_proc.call(*args, &block)
-
-          if _options[:group_by]
-            results = Array(results)
-            send_args = if results.first && results.first.kind_of?(Hash)
-              [:[]]
-            else
-              []
-            end
-
-            if _options[:one]
-              results.inject({}) do |hash, r|
-                key = r.send(*send_args, _options[:group_by])
-                hash[key] = r
-                hash
-              end
-            else
-              results.inject({}) do |hash, r|
-                key = r.send(*send_args, _options[:group_by])
-                (hash[key] ||= []).push(r)
-                hash
-              end
-            end
-          elsif _options[:array_to_hash]
-            Array(results).inject({}) do |hash, r|
-              hash[r[0]] = r[1]
-              hash
-            end
-          else
-            results
-          end
-        end
-      end
-    end
-  end
-
-  class Datasource::Base
-  private
-    def self.loader(name, _options = {}, &block)
-      klass = Class.new(Attributes::Loader) do
-        # depends deps
-        options(_options)
-        self._load_proc = block
-      end
-      @_loaders[name.to_sym] = klass
-    end
-
-    def self.loaded(name, _options = {}, &block)
-      loader(name, _options, &block)
-      renamed_existing_method = :"#{name}_without_datasource"
-      orm_klass.class_eval do
-        alias_method renamed_existing_method, name if method_defined?(name)
-        fail "#{name} already defined on #{to_s}, would be overridden by datasource loaded method" if method_defined?(name)
-        define_method name do |*args, &block|
-          if loaded_values || !method_defined?(renamed_existing_method)
-            loaded_values[name.to_sym]
-          else
-            send(renamed_existing_method, *args, &block)
-          end
-        end
-      end
-      computed name, loader: name
-    end
-  end
-end

data/lib/datasource/serializer.rb

@@ -1,117 +0,0 @@
-module Datasource
-  class Serializer
-    TemplatePart = Struct.new(:parent, :type, :value, :select) do
-      def initialize(parent, type = nil, value = nil)
-        super(parent, type, get_default_value(type, value), [])
-      end
-
-      def set_default_value(value = nil)
-        self.value = get_default_value(type, value)
-      end
-    private
-      def get_default_value(type, value)
-        case type
-        when :hash then {}
-        when :array then []
-        when :datasource then value
-        when nil then nil
-        else
-          fail "Unknown type #{type}"
-        end
-      end
-    end
-
-    class << self
-      attr_accessor :datasource_count, :template
-
-      def inherited(base)
-        base.datasource_count = 0
-        @cursor = base.template = nil
-      end
-
-      def with_new_cursor(type, value = nil, &block)
-        result = nil
-        new_cursor = TemplatePart.new(@cursor, type, value)
-        @cursor = @cursor.tap do
-          if template.nil?
-            self.template = @cursor = new_cursor
-          elsif @cursor.type == :datasource
-            @cursor = @cursor.parent
-            return with_new_cursor(type, value, &block)
-          elsif @cursor.type == :array
-            @cursor = new_cursor
-            @cursor.parent.push(@cursor)
-          elsif @cursor.type.nil?
-            # replace cursor
-            @cursor.type = type
-            @cursor.set_default_value(value)
-          else
-            fail "Invalid use of #{type}."
-          end
-          result = block.call
-        end
-        result
-      end
-
-      def hash(&block)
-        with_new_cursor(:hash, &block)
-      end
-
-      def key(name)
-        fail "Cannot use key outside hash." unless template && @cursor.type == :hash
-        @cursor = @cursor.tap do
-          @cursor = @cursor.value[name.to_s] = TemplatePart.new(@cursor)
-          yield
-        end
-      end
-
-      def array(&block)
-        with_new_cursor(:array, &block)
-      end
-
-      def datasource(ds)
-        self.datasource_count += 1
-        @cursor = with_new_cursor(:datasource, ds) { @cursor }
-      end
-
-      def attributes(*attributes)
-        attributes.each { |name| attribute name }
-      end
-
-      def attribute(name)
-        fail "No datasource selected - use \"select_datasource Klass\" first." unless template && @cursor.type == :datasource
-        @cursor.select << name
-      end
-    end
-
-    def initialize(*scopes)
-      @scopes = scopes
-      if @scopes.size != self.class.datasource_count
-        fail ArgumentError, "#{self.class.name} needs #{self.class.datasource_count} scopes, you provided #{@scopes.size}"
-      end
-    end
-
-    def as_json
-      parse_template_part(self.class.template)
-    end
-
-  private
-    def parse_template_part(part)
-      return nil unless part
-      case part.type
-      when :hash
-        {}.tap do |result|
-          part.value.each_pair do |k, v|
-            result[k] = parse_template_part(v)
-          end
-        end
-      when :array
-        part.value.map { |v| parse_template_part(v) }
-      when :datasource
-        part.value.new(@scopes.shift).select(*part.select).results
-      else
-        fail "Unknown type #{type}"
-      end
-    end
-  end
-end