active_file_record 0.0.2a → 0.0.3a

data/lib/active_file_record/relation.rb

@@ -0,0 +1,73 @@
+require 'active_support/core_ext/object/blank'
+
+module ActiveFileRecord
+  class Relation
+    include SearchMethods, FinderMethods
+
+    delegate :file_handler, :filename, :primary_key, :to => :klass
+
+    MULTI_VALUE_METHODS = [:where]
+    SINGLE_VALUE_METHODS = [:limit]
+
+    attr_accessor :default_scoped
+
+    attr_reader :file, :klass, :loaded
+    attr_accessor :extensions, :default_scoped
+    alias :loaded? :loaded
+
+
+    def initialize(klass, file)
+      @klass = klass
+      @file = file
+
+      @implicit_readonly = nil
+      @loaded            = false
+      @default_scoped    = false
+
+      SINGLE_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_value", nil)}
+      MULTI_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_values", [])}
+      @extensions = []
+      @create_with_value = {}
+    end
+
+    def inspect
+      to_a.inspect
+    end
+
+    def to_a
+        exec_queries
+    end
+
+    def exec_queries
+      return @records if loaded?
+      default_scoped = self
+      @records = find_with_associations
+      @loaded = true
+      @records
+    end
+
+    def merge(r)
+      return self unless r
+      return to_a & r if r.is_a?(Array)
+
+      merged_relation = clone
+      merged_wheres = @where_values + r.where_values
+
+      merged_relation.where_values = merged_wheres
+
+      (Relation::SINGLE_VALUE_METHODS - [:lock, :create_with, :reordering]).each do |method|
+        value = r.send(:"#{method}_value")
+        merged_relation.send(:"#{method}_value=", value) unless value.nil?
+      end
+
+      # Apply scope extension modules
+      merged_relation.send :apply_modules, r.extensions
+
+      merged_relation
+    end
+
+    private :exec_queries
+
+
+  end
+end

data/lib/active_file_record/relation/finder_methods.rb

@@ -0,0 +1,88 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module ActiveFileRecord
+  module FinderMethods
+    def find(*args)
+      case args.first
+      when :first, :last, :all
+        send(args.first)
+      else
+        find_with_ids(*args)
+      end
+    end
+
+    # A convenience wrapper for <tt>find(:first, *args)</tt>. You can pass in all the
+    # same arguments to this method as you can to <tt>find(:first)</tt>.
+    def first #(*args)
+      #if args.any?
+      #  if args.first.kind_of?(Integer) || (loaded? && !args.first.kind_of?(Hash))
+      #    limit(*args).to_a
+      #  else
+      #    apply_finder_options(args.first).first
+      #  end
+      #else
+        find_first
+      #end
+    end
+
+
+    # A convenience wrapper for <tt>find(:last, *args)</tt>. You can pass in all the
+    # same arguments to this method as you can to <tt>find(:last)</tt>.
+    def last(*args)
+        find_last
+    end
+
+    # A convenience wrapper for <tt>find(:all, *args)</tt>. You can pass in all the
+    # same arguments to this method as you can to <tt>find(:all)</tt>.
+    def all(*args)
+      args.any? ? apply_finder_options(args.first).to_a : to_a
+    end
+
+
+    protected
+
+
+    def find_with_ids(*ids)
+      #ids = ids.flatten.compact.uniq
+
+      case ids.size
+
+      when 0
+        raise RecordNotFound, "Couldn't find #{@klass.name} without an ID"
+      when 1
+        result = find_one(ids.first.to_i)
+      end
+    end
+
+    def find_one(id)
+      column = :id
+      relation = where({primary_key=>{:eq => id}})
+      record = relation.first
+
+      unless record
+        raise RecordNotFound , "Couldn't find #{@klass.name}"
+      end
+
+      record
+    end
+
+    def find_first
+      if loaded?
+        @records.first
+      else
+        @first ||= limit(1).to_a[0]
+      end
+    end
+
+    def find_last
+      if loaded?
+        @records.last
+      else
+        to_a.last
+        @last ||= to_a.last
+      end
+    end
+
+  end
+end

data/lib/active_file_record/relation/predicate_builder.rb

@@ -0,0 +1,21 @@
+module ActiveFileRecord
+  class PredicateBuilder # :nodoc:
+    def self.build_from_hash(attributes, default_file)
+      file = default_file
+
+      # FIXME: We need to sanitize attributes
+
+      predicates = attributes.map do |field, value|
+        active_file = ActiveFile.new(file)
+        attribute = active_file[field.to_sym]
+
+        compare_method = value.keys.first
+        attr_value = value.values.first
+
+        attribute.send(compare_method, attr_value)
+      end
+
+      predicates.flatten
+    end
+  end
+end

data/lib/active_file_record/relation/search_methods.rb

@@ -0,0 +1,65 @@
+#require 'active_support/core_ext/array/wrap'
+#require 'active_support/core_ext/object/blank'
+
+module ActiveFileRecord
+  module SearchMethods
+    extend ActiveSupport::Concern
+
+    attr_accessor :where_values, :limit_value
+
+    def select
+        relation = clone
+        relation
+    end
+
+    def where(opts)
+      return self if opts.blank?
+
+      relation = clone
+      relation.where_values += build_where(opts)
+      relation
+    end
+
+    def limit(value)
+      relation = clone
+      relation.limit_value = value
+      relation
+    end
+
+    private
+
+    def build_where(opts)
+      PredicateBuilder.build_from_hash(opts, filename)
+    end
+
+
+    def apply_modules(modules)
+      unless modules.empty?
+        @extensions += modules
+        modules.each {|extension| extend(extension) }
+      end
+    end
+
+    protected
+
+    def find_with_associations
+      relation = construct_relation_for_association_find
+      rows = file_handler.select_all(relation)
+    end
+
+    def construct_relation_for_association_find
+      result = self.class.new(@klass, file)
+      result.default_scoped = default_scoped
+
+      Relation::MULTI_VALUE_METHODS.each do |method|
+        result.send(:"#{method}_values=", send(:"#{method}_values"))
+      end
+
+      Relation::SINGLE_VALUE_METHODS.each do |method|
+        result.send(:"#{method}_value=", send(:"#{method}_value"))
+      end
+
+      relation = result.select
+    end
+  end
+end

data/lib/active_file_record/scoping.rb

@@ -0,0 +1,28 @@
+require 'active_support/concern'
+
+module ActiveFileRecord
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      include Named
+    end
+
+    module ClassMethods
+
+      def unscoped
+        block_given? ? relation.scoping { yield } : relation
+      end
+
+
+      protected
+      def current_scope #:nodoc:
+        Thread.current["#{self}_current_scope"]
+      end
+      #
+      def current_scope=(scope) #:nodoc:
+        Thread.current["#{self}_current_scope"] = scope
+      end
+    end
+  end
+end

data/lib/active_file_record/scoping/named.rb

@@ -0,0 +1,72 @@
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveFileRecord
+  # = Active Record Named \Scopes
+  module Scoping
+    module Named
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        def scoped(options = nil)
+
+          if options
+            scoped.apply_finder_options(options)
+          else
+            if current_scope
+              current_scope.clone
+            else
+              scope = relation
+              scope.default_scoped = true
+              scope
+            end
+          end
+        end
+
+        def scope_attributes # :nodoc:
+          if current_scope
+            current_scope.scope_for_create
+          else
+            scope = relation
+            scope.default_scoped = true
+            scope.scope_for_create
+          end
+        end
+
+        def scope_attributes? # :nodoc:
+          current_scope || default_scopes.any?
+        end
+
+        def scope(name, scope_options = {})
+          name = name.to_sym
+          valid_scope_name?(name)
+          extension = Module.new(&Proc.new) if block_given?
+
+          scope_proc = lambda do |*args|
+            options = scope_options.respond_to?(:call) ? unscoped { scope_options.call(*args) } : scope_options
+            options = scoped.apply_finder_options(options) if options.is_a?(Hash)
+
+            relation = scoped.merge(options)
+
+            extension ? relation.extending(extension) : relation
+          end
+
+          singleton_class.send(:redefine_method, name, &scope_proc)
+        end
+
+      protected
+
+        def valid_scope_name?(name)
+          if logger && respond_to?(name, true)
+            logger.warn "Creating scope :#{name}. " \
+                        "Overwriting existing method #{self.name}.#{name}."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_file_record/validations.rb

@@ -0,0 +1,12 @@
+module ActiveFileRecord
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    def save
+      true
+      valid? ? super : false
+    end
+
+  end
+end

data/lib/active_file_record/version.rb

@@ -1,3 +1,3 @@
 module ActiveFileRecord
-  VERSION = "0.0.2a"
+  VERSION = "0.0.3a"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_file_record
 version: !ruby/object:Gem::Version
-  version: 0.0.2a
+  version: 0.0.3a
   prerelease: 5
 platform: ruby
 authors:
@@ -25,6 +25,38 @@ files:
 - Rakefile
 - active_file_record.gemspec
 - lib/active_file_record.rb
+- lib/active_file_record/associations.rb
+- lib/active_file_record/associations/association.rb
+- lib/active_file_record/associations/association_scope.rb
+- lib/active_file_record/associations/belongs_to_association.rb
+- lib/active_file_record/associations/builder/association.rb
+- lib/active_file_record/associations/builder/belongs_to.rb
+- lib/active_file_record/associations/singular_association.rb
+- lib/active_file_record/attribute_assignment.rb
+- lib/active_file_record/attribute_methods.rb
+- lib/active_file_record/attribute_methods/read.rb
+- lib/active_file_record/attribute_methods/write.rb
+- lib/active_file_record/base.rb
+- lib/active_file_record/callbacks.rb
+- lib/active_file_record/criteria.rb
+- lib/active_file_record/file_handler.rb
+- lib/active_file_record/file_handler/active_file.rb
+- lib/active_file_record/file_handler/attribute.rb
+- lib/active_file_record/inheritance.rb
+- lib/active_file_record/integration.rb
+- lib/active_file_record/nodes.rb
+- lib/active_file_record/nodes/binary.rb
+- lib/active_file_record/nodes/equality.rb
+- lib/active_file_record/persistence.rb
+- lib/active_file_record/predications.rb
+- lib/active_file_record/reflection.rb
+- lib/active_file_record/relation.rb
+- lib/active_file_record/relation/finder_methods.rb
+- lib/active_file_record/relation/predicate_builder.rb
+- lib/active_file_record/relation/search_methods.rb
+- lib/active_file_record/scoping.rb
+- lib/active_file_record/scoping/named.rb
+- lib/active_file_record/validations.rb
 - lib/active_file_record/version.rb
 homepage: ''
 licenses: []