rom-fmp 0.0.4

data/lib/rom/fmp/header.rb

@@ -0,0 +1,57 @@
+###  NOT CURRENTLY USED  ###
+
+module ROM
+  module FMP
+    # @private
+    class Header
+      include Equalizer.new(:columns, :table)
+
+      attr_reader :columns, :table
+
+      def initialize(columns, table)
+        @columns = columns
+        @table = table
+      end
+
+      def to_ary
+        columns
+      end
+      alias_method :to_a, :to_ary
+
+      def to_h
+        columns.each_with_object({}) do |col, h|
+          left, right = col.to_s.split('___')
+          h[left.to_sym] = (right || left).to_sym
+        end
+      end
+
+      def names
+        columns.map { |col| :"#{col.to_s.split('___').last}" }
+      end
+
+      def project(*names)
+        self.class.new(columns.find_all { |col| names.include?(col) }, table)
+      end
+
+      def qualified
+        self.class.new(columns.map { |col| :"#{table}__#{col}" }, table)
+      end
+
+      def rename(options)
+        self.class.new(columns.map { |col|
+          new_name = options[col]
+
+          if new_name
+            :"#{col}___#{new_name}"
+          else
+            col
+          end
+        }, table)
+      end
+
+      def prefix(col_prefix)
+        rename(Hash[columns.map { |col| [col, :"#{col_prefix}_#{col}"] }])
+      end
+    end
+  end
+end

data/lib/rom/fmp/micro01.rb

@@ -0,0 +1,55 @@
+# This is an alternative version of rom-fmp, with all moduels & classes in a single file.
+
+require 'logger'
+require 'rom'
+require 'rfm'
+require 'yaml'
+
+class Rfm::Layout
+  def to_a
+    all(:max_records=>10)
+  end
+  
+  def each
+    # passes block - if any - to upstream each.
+    to_a.each(&Proc.new)
+  end
+end
+
+module ROM
+  module FMP
+  
+  
+    class Gateway < ROM::Gateway
+      attr_reader :datasets
+      
+      def initialize(*options)
+        @datasets = Rfm.database(options[0].to_h.merge(FMRESULTSET_TEMPLATE).to_h)
+      end
+      
+      def dataset(name)
+        datasets[name.to_s]
+      end
+      
+      # This is required per lint specs
+      alias_method :[], :dataset
+      
+      def dataset?(name)
+        datasets.layouts.key?(name.to_s)
+      end
+    end
+  
+  
+    class Relation < ROM::Relation
+      # we must configure adapter identifier here
+      adapter :fmp
+
+      forward :find, :any, :all
+    end
+
+    
+
+
+
+  end # FMP
+end # ROM

data/lib/rom/fmp/micro02.rb

@@ -0,0 +1,161 @@
+# This is an alternative version of rom-fmp, with all moduels & classes in a single file.
+
+require 'logger'
+require 'rom/gateway'
+require 'rfm'
+require 'charlatan'
+require 'yaml'
+
+class Rfm::Layout
+  # Strip out unnecessary output in Rfm::Layout#inspect
+  def inspect
+    "#<#{self.class.name}:#{self.object_id} @name=#{self.name} @database=#{database.name} @server=#{server.host_name} @loaded=#{@loaded}>"
+  end
+end
+
+module ROM
+  module FMP
+  
+  
+    class Gateway < ROM::Gateway
+      attr_reader :datasets, :database
+      
+      def initialize(*options)
+        @database = Rfm.database(options[0].to_h.merge(FMRESULTSET_TEMPLATE).to_h)
+        @datasets = Hash.new
+      end
+      
+      def dataset(name)
+        datasets[name.to_s] ||= Dataset.new(@database[name.to_s])
+      end
+      
+      # This is required per lint specs
+      alias_method :[], :dataset
+      
+      def dataset?(name)
+        datasets.key?(name.to_s)
+      end
+    end
+    
+    
+    class Dataset
+      include ::Rfm::Scope
+      
+      DEFAULT_REQUEST_OPTIONS = {}
+      
+      # Dataset instance expects to hold Array of data in @data,
+      # but it will also hold a FM Layout instance.
+      # If any call to Dataset instance returns Array instance,
+      # it will be wrapped in a new Dataset instance.
+      include Charlatan.new(:data, kind: Array)
+      attr_reader :layout, :data, :queries
+
+      # Store layout, data, query in new dataset.
+      def initialize(_layout, _data=[], _queries=[])
+        @layout = _layout
+        @queries = _queries
+        #puts "DATASET NEW queries:#{@queries}"
+        super(_data)
+      end
+      
+      
+      
+      # Creates new dataset with current args and resultset. Not lazy.
+      # This may not be how rom or sql uses 'where'. Find out more.
+      def where(*args)
+        #self.class.new(layout, layout.find(*args), args)
+        get_results(:find, args)
+      end
+      
+      # Creates new dataset with existing data & queries, plus new query
+      def find(*args)
+        #self.class.new(layout, data, (queries.dup << args))
+        wrap_data(data, (queries.dup << args))
+      end
+      
+      def any(options={})
+        wrap_data(layout.any(options))
+      end
+      
+      def all(options={})
+        wrap_data(layout.all(DEFAULT_REQUEST_OPTIONS.merge(options)))
+      end
+      
+      def count(*args)
+        compiled_query = compile_query
+        compiled_query ? layout.count(*compiled_query) : layout.total_count
+      end
+      
+      def create(args={})
+        get_results(:create, [args]) unless args.empty?
+      end
+
+      def update(record_id, args={})
+        get_results(:edit, [record_id, args]) unless args.empty?
+      end
+      
+      def delete(record_id)
+        get_results(:delete, record_id)
+      end      
+
+
+
+      # Triggers actual fm action.
+      def to_a
+        (data.nil? || data.empty?) ? call.data.to_a : data.to_a
+      end
+      
+      # Triggers actual fm action.
+      def each
+        # passes block - if any - to upstream each.
+        to_a.each(&Proc.new)
+      end
+      
+      # Combines all queries, sends to FM, returns result in new dataset.
+      def call
+        compiled_query = compile_query
+        wrap_data(compiled_query ? layout.find(*compiled_query) : layout.all(DEFAULT_REQUEST_OPTIONS))
+      end
+      
+      # Mixes chained queries together into single query.
+      # Now works with multiple-request queries (using new rfm scope feature).
+      # Other ways: consider mixing multi-request queries with intersection: (result1 & result2),
+      # or with the new scope feature: query1(scope:query2(scope:query3))
+      def compile_query
+        #puts "DATASET COMPILE self #{self}"
+        #puts "DATASET COMPILE queries #{queries}"
+        
+        # Old way: works but doesn't handle fmp compound queries.
+        #query.each_with_object([{},{}]){|x,o| o[0].merge!(x[0] || {}); o[1].merge!(x[1] || {})}
+        
+        # New way: handles compound queries. Reqires ginjo-rfm 3.0.11.
+        return unless queries  # This should help introspecting dataset that results from record deletion. TODO: test this.
+        queries.inject {|new_query,scope| apply_scope(new_query, scope)} ##puts "SCOPE INJECTION scope:#{scope} new_query:#{new_query}"; 
+      end
+            
+      # Returns new dataset containing, data, layout, query.
+      def wrap_data(_data=data, _queries=queries, _layout=layout)
+        self.class.new(_layout, _data, _queries)
+      end
+      
+      # Send method & query to layout, and wrap results in new dataset.
+      def get_results(_method, query=queries, _layout=layout)
+        wrap_data(_layout.send(_method, *query), query, _layout)
+      end
+
+    end # Dataset
+  
+  
+    class Relation < ROM::Relation
+      # we must configure adapter identifier here
+      adapter :fmp
+
+      forward :find, :all, :count, :create, :update, :delete
+    end
+
+    
+
+
+
+  end # FMP
+end # ROM

data/lib/rom/fmp/mini.rb

@@ -0,0 +1,91 @@
+# This is an alternative version of rom-fmp, with all moduels & classes in a single file.
+
+require 'logger'
+require 'rom/gateway'
+require 'rom/fmp/commands'
+require 'rfm'
+require 'yaml'
+
+
+module ROM
+  module FMP
+  
+    class Relation < ROM::Relation
+      adapter :fmp
+      forward :find, :where, :all, :any, :count
+    end
+    
+
+    class Gateway < ROM::Gateway
+      attr_reader :sets
+
+      def initialize(uri, options = {})
+        puts "INITIALIZING GATEWAY WITH uri: #{uri} options: #{options}"
+        @connection = connect(uri, options)
+        @sets = {}
+        self
+      end
+
+      def dataset(name)
+        sets[name] = Dataset.new(name, connection)
+      end
+
+      def [](name)
+        sets.fetch(name)
+      end
+
+      def dataset?(name)
+        sets.key?(name)
+      end
+      
+      def connect(*args)
+        options = args.last.kind_of?(Hash) ? args.pop : Hash.new
+        options.merge! args.pop if args.last.kind_of?(Hash)
+        case args[0]
+        when Rfm::Database
+          args[0]
+        else
+          #::Rfm::Database.new(uri[:database], *Array([uri.to_s, *args]).flatten)
+          #Rfm.layout(storage_name, gateway.adapter.options.merge(FMRESULTSET_TEMPLATE).symbolize_keys)
+          Rfm.database(*args, options.to_h.merge(FMRESULTSET_TEMPLATE).to_h)
+        end
+      end
+      
+    end # Gateway
+
+
+    class Dataset
+      #include Equalizer.new(:name, :connection)
+
+      attr_reader :name, :connection, :table
+
+      def initialize(name, connection)
+        puts "INITIALIZING DATASET WITH name: #{name} connection: #{connection}"
+        @name = name
+        @connection = connection
+        @table = connection[name.to_s]
+        self
+      end
+
+      def find(*args)
+        table.find(*args)
+      end
+  
+      def each(&block)
+        table.all(:max_records=>10).each(&block)
+      end     
+      
+      def to_a
+        table.all(:max_records=>10)
+      end
+      
+      private
+      
+      # def table
+      #   @table ||= connection[name]
+      # end
+      
+    end # Dataset
+
+  end # FMP
+end # ROM

data/lib/rom/fmp/relation.rb

@@ -0,0 +1,18 @@
+require 'rom'
+#require 'rom/fmp/header'
+#require 'rom/fmp/relation/class_methods'
+#require 'rom/fmp/relation/inspection'
+#require 'rom/fmp/relation/associations'
+
+module ROM
+  module FMP
+  
+    class Relation < ROM::Relation
+      # we must configure adapter identifier here
+      adapter :fmp
+
+      forward :find, :all, :count, :create, :update, :delete
+    end
+    
+  end
+end

data/lib/rom/fmp/relation/associations.rb

@@ -0,0 +1,104 @@
+module ROM
+  module SQL
+    class Relation < ROM::Relation
+      module Associations
+        # Join configured association.
+        #
+        # Uses INNER JOIN type.
+        #
+        # @example
+        #
+        #   setup.relation(:tasks)
+        #
+        #   setup.relations(:users) do
+        #     one_to_many :tasks, key: :user_id
+        #
+        #     def with_tasks
+        #       association_join(:tasks, select: [:title])
+        #     end
+        #   end
+        #
+        # @api public
+        def association_join(name, options = {})
+          graph_join(name, :inner, options)
+        end
+
+        # Join configured association
+        #
+        # Uses LEFT JOIN type.
+        #
+        # @example
+        #
+        #   setup.relation(:tasks)
+        #
+        #   setup.relations(:users) do
+        #     one_to_many :tasks, key: :user_id
+        #
+        #     def with_tasks
+        #       association_left_join(:tasks, select: [:title])
+        #     end
+        #   end
+        #
+        # @api public
+        def association_left_join(name, options = {})
+          graph_join(name, :left_outer, options)
+        end
+
+        # @api private
+        def graph_join(name, join_type, options = {})
+          assoc = model.association_reflection(name)
+
+          key = assoc[:key]
+          type = assoc[:type]
+
+          if type == :many_to_many
+            select = options[:select] || {}
+            graph_join_many_to_many(name, assoc, select)
+          else
+            graph_join_other(name, key, type, join_type, options)
+          end
+        end
+
+        # @api private
+        def graph(*args)
+          __new__(dataset.__send__(__method__, *args))
+        end
+
+        private
+
+        def graph_join_many_to_many(name, assoc, select)
+          l_select, r_select =
+            if select.is_a?(Hash)
+              [select[assoc[:join_table]] || [], select[name]]
+            else
+              [[], select]
+            end
+
+          l_graph = graph(
+            assoc[:join_table],
+            { assoc[:left_key] => primary_key },
+            select: l_select, implicit_qualifier: self.name
+          )
+
+          l_graph.graph(
+            name, { primary_key => assoc[:right_key] }, select: r_select
+          )
+        end
+
+        def graph_join_other(name, key, type, join_type, options)
+          join_keys =
+            if type == :many_to_one
+              { primary_key => key }
+            else
+              { key => primary_key }
+            end
+
+          graph(
+            name, join_keys,
+            options.merge(join_type: join_type, implicit_qualifier: self.name)
+          )
+        end
+      end
+    end
+  end
+end