active_file_record 0.0.2a → 0.0.3a

data/lib/active_file_record/attribute_methods/read.rb

@@ -0,0 +1,26 @@
+module ActiveFileRecord
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+      include ActiveModel::AttributeMethods
+
+      included do
+        attribute_method_prefix ""
+      end
+
+      module ClassMethods
+        def define_method_attribute(attr_name)
+          generated_attribute_methods.send(:define_method, "#{attr_name}") do
+            read_attribute(attr_name.to_s)
+          end
+        end
+      end
+
+      def read_attribute(attr_name)
+        attr_name = attr_name.to_sym
+        @attributes[attr_name]
+      end
+
+    end
+  end
+end

data/lib/active_file_record/attribute_methods/write.rb

@@ -0,0 +1,27 @@
+module ActiveFileRecord
+  module AttributeMethods
+    module Write
+      extend ActiveSupport::Concern
+      include ActiveModel::AttributeMethods
+
+      included do
+        attribute_method_suffix "="
+      end
+
+      module ClassMethods
+        protected
+        def define_method_attribute=(attr_name)
+          generated_attribute_methods.send(:define_method, "#{attr_name}=") do |new_value|
+            write_attribute(attr_name, new_value)
+          end
+        end
+      end
+
+      def write_attribute(attr_name, value)
+        attr_name = attr_name.to_sym
+        @attributes[attr_name] = value
+      end
+
+    end
+  end
+end

data/lib/active_file_record/base.rb

@@ -0,0 +1,81 @@
+require 'active_support/core_ext/module/delegation'
+
+module ActiveFileRecord
+
+  class MissingAttributeError < NoMethodError
+  end
+
+  class RecordNotFound < Exception
+  end
+
+  class Base
+    include Criteria
+    include Persistence
+    include Validations
+    include Callbacks
+    include AttributeAssignment
+    include AttributeMethods
+    include Associations
+    extend Criteria
+    include Scoping
+    include Inheritance
+    include Reflection
+    include Integration
+
+    extend ActiveModel::Naming
+
+    fields :id
+
+    attr_reader :attributes, :new_record, :destroyed
+    attr_accessor :filename
+
+
+    def initialize(attributes = nil,  options = {})
+      @new_record = true
+      @destroyed = false
+      @attributes = self.class.initialize_attributes(self.class._fields.dup)
+      @association_cache = {}
+      assign_attributes(attributes, options) if attributes
+    end
+
+    def init_with(attributes = nil)
+      @association_cache = {}
+      @attributes = self.class.initialize_attributes(self.class._fields.dup)
+      assign_attributes(attributes, {:without_protection => true}) if attributes
+      @new_record = false
+      @destroyed = false
+      self
+    end
+
+    class << self
+      def filename
+        @filename ||= self.name.underscore
+      end
+
+      def filename=(name)
+        @filename = name
+      end
+
+      def primary_key
+        :id
+      end
+
+      def generated_feature_methods
+        @generated_feature_methods ||= begin
+          mod = const_set(:GeneratedFeatureMethods, Module.new)
+          include mod
+          mod
+        end
+      end
+
+      def file_handler
+        @file_handler ||= FileHandler.new(filename)
+      end
+
+      def relation
+        relation = Relation.new(self, file_handler)
+      end
+    end
+
+  end
+end

data/lib/active_file_record/callbacks.rb

@@ -0,0 +1,21 @@
+module ActiveFileRecord
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :save, :destroy
+    end
+
+
+    def save
+      run_callbacks(:save) { super }
+    end
+
+    def destroy
+      run_callbacks(:destroy) { super }
+    end
+  end
+end

data/lib/active_file_record/criteria.rb

@@ -0,0 +1,10 @@
+require 'active_support/core_ext/module/delegation'
+
+module ActiveFileRecord
+  module Criteria
+    delegate :find, :first, :last, :all, :to => :scoped
+    delegate :select, :where, :to => :scoped
+
+    extend ActiveSupport::Concern
+  end
+end

data/lib/active_file_record/file_handler.rb

@@ -0,0 +1,66 @@
+module ActiveFileRecord
+  class FileHandler
+    attr_reader :filename
+
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def add_record(klass)
+      entries = file_entries(filename) || []
+
+      p entries
+
+      entries << klass.attributes
+      rewrite filename, entries
+    end
+
+    def select_all(relation)
+      load(relation)
+    end
+
+    private
+    def rewrite(filename, entries)
+      File.open(entries_file(filename), "w") do |f|
+        f.write(ActiveSupport::JSON.encode entries)
+      end
+    end
+
+    def load(relation)
+      result = []
+      entries = file_entries relation.klass.filename
+
+      if entries.is_a?(Array)
+        entries.each do |entry|
+          if check_entry(entry, relation.where_values)
+            result << relation.klass.instantiate(entry)
+          end
+        end
+      end
+
+      p "Searchin in #{relation.klass.filename}"
+
+      result
+    end
+
+    def check_entry(entry, where)
+      suitable = true
+
+      where.each do |condition|
+        suitable &&= entry[condition.operand1.name.to_s].send(condition.operator, condition.operand2)
+        return false if !suitable
+      end
+
+      true
+    end
+
+    def file_entries(filename)
+      ActiveSupport::JSON.decode(File.read(entries_file filename))
+    end
+
+    def entries_file(filename)
+      File.join(Rails.root, "records_storage", filename)
+    end
+
+  end
+end

data/lib/active_file_record/file_handler/active_file.rb

@@ -0,0 +1,13 @@
+module ActiveFileRecord
+  class ActiveFile
+    attr_accessor :filename
+
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def [] name
+      Attribute.new self, name
+    end
+  end
+end

data/lib/active_file_record/file_handler/attribute.rb

@@ -0,0 +1,5 @@
+module ActiveFileRecord
+    class Attribute < Struct.new :relation, :name
+      include ActiveFileRecord::Predications
+    end
+end

data/lib/active_file_record/inheritance.rb

@@ -0,0 +1,42 @@
+require 'active_support/concern'
+module ActiveFileRecord
+  module Inheritance
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def instantiate(record)
+        instance = self.allocate.init_with(record)
+        instance
+      end
+
+      protected
+
+      def compute_type(type_name)
+        if type_name.match(/^::/)
+          # If the type is prefixed with a scope operator then we assume that
+          # the type_name is an absolute reference.
+          ActiveSupport::Dependencies.constantize(type_name)
+        else
+          # Build a list of candidates to search for
+          candidates = []
+          name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+          candidates << type_name
+
+          candidates.each do |candidate|
+            begin
+              constant = ActiveSupport::Dependencies.constantize(candidate)
+              return constant if candidate == constant.to_s
+            rescue NameError => e
+              # We don't want to swallow NoMethodError < NameError errors
+              raise e unless e.instance_of?(NameError)
+            end
+          end
+
+          raise NameError, "uninitialized constant #{candidates.first}"
+        end
+      end
+    end
+
+  end
+end

data/lib/active_file_record/integration.rb

@@ -0,0 +1,13 @@
+module ActiveFileRecord
+  module Integration
+    def to_param
+      id && id.to_s
+    end
+
+    def to_key
+      key = self.id
+      [key] if key
+    end
+
+  end
+end

data/lib/active_file_record/nodes.rb

@@ -0,0 +1,2 @@
+require 'active_file_record/nodes/binary'
+require 'active_file_record/nodes/equality'

data/lib/active_file_record/nodes/binary.rb

@@ -0,0 +1,19 @@
+module ActiveFileRecord
+  module Nodes
+    class Binary
+      attr_accessor :left, :right
+
+      def initialize left, right
+        @left  = left
+        @right = right
+      end
+
+      def initialize_copy other
+        super
+        @left  = @left.clone if @left
+        @right = @right.clone if @right
+      end
+    end
+
+  end
+end

data/lib/active_file_record/nodes/equality.rb

@@ -0,0 +1,11 @@
+module ActiveFileRecord
+  module Nodes
+    class Equality < ActiveFileRecord::Nodes::Binary
+      attr_reader :operator
+
+      def operator; :== end
+      alias :operand1 :left
+      alias :operand2 :right
+    end
+  end
+end

data/lib/active_file_record/persistence.rb

@@ -0,0 +1,53 @@
+module ActiveFileRecord
+  module Persistence
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+
+    included do
+      class_attribute :include_root_in_json
+      self.include_root_in_json = false
+    end
+
+    def save
+      create
+    end
+
+    def create
+      self.id = generate_id
+      self.class.file_handler.add_record(self)
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    # Returns if the record is persisted, i.e. it's not a new record and it was
+    # not destroyed.
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    #def update
+    #end
+
+    #def destroy
+    #end
+
+    #def update_attributes(attributes)
+      #@attributes.merge!(attributes)
+      #sanitize_attributes
+      #save
+    #end
+
+    private
+    def generate_id
+      last_entry = self.class.last
+      last_entry ? last_entry.id + 1 : 1
+    end
+
+  end
+end

data/lib/active_file_record/predications.rb

@@ -0,0 +1,9 @@
+module ActiveFileRecord
+  module Predications
+
+    def eq other
+      Nodes::Equality.new self, other
+    end
+
+  end
+end

data/lib/active_file_record/reflection.rb

@@ -0,0 +1,140 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/object/inclusion'
+
+module ActiveFileRecord
+  module Reflection
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :reflections
+      self.reflections = {}
+    end
+
+    module ClassMethods
+      def create_reflection(macro, name, options, active_file_record)
+            klass = options[:through] ? ThroughReflection : AssociationReflection
+            reflection = klass.new(macro, name, options, active_file_record)
+
+        self.reflections = self.reflections.merge(name => reflection)
+        reflection
+      end
+
+      def reflect_on_association(association)
+        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+      end
+    end
+
+    class MacroReflection
+      attr_reader :name
+      attr_reader :macro
+      attr_reader :options
+      attr_reader :active_file_record
+
+      def initialize(macro, name, options, active_file_record)
+        @macro         = macro
+        @name          = name
+        @options       = options
+        @active_file_record = active_file_record
+      end
+
+      def klass
+        @klass ||= class_name.constantize
+      end
+
+      def class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
+      end
+
+      private
+        def derive_class_name
+          name.to_s.camelize
+        end
+    end
+
+    class AssociationReflection < MacroReflection #:nodoc:
+      def klass
+        @klass ||= active_file_record.send(:compute_type, class_name)
+      end
+
+      def initialize(macro, name, options, active_record)
+        super
+        @collection = macro.in?([:has_many, :has_and_belongs_to_many])
+      end
+
+      def build_association(*options, &block)
+        klass.new(*options, &block)
+      end
+
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key
+      end
+
+      def foreign_type
+        @foreign_type ||= options[:foreign_type] || "#{name}_type"
+      end
+
+      def type
+        @type ||= options[:as] && "#{options[:as]}_type"
+      end
+
+      def primary_key_column
+        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
+      end
+
+      def association_foreign_key
+        @association_foreign_key ||= options[:association_foreign_key] || class_name.foreign_key
+      end
+
+      def association_primary_key(klass = nil)
+        options[:primary_key] || primary_key(klass || self.klass)
+      end
+
+      def chain
+        [self]
+      end
+
+      def nested?
+        false
+      end
+
+      def conditions
+        [[options[:conditions]].compact]
+      end
+
+      alias :source_macro :macro
+
+      def has_inverse?
+        @options[:inverse_of]
+      end
+
+      def inverse_of
+        if has_inverse?
+          @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
+        end
+      end
+
+      def collection?
+        @collection
+      end
+
+      # Returns +true+ if +self+ is a +belongs_to+ reflection.
+      def belongs_to?
+        macro == :belongs_to
+      end
+
+      def association_class
+        Associations::BelongsToAssociation
+      end
+
+      private
+        def derive_foreign_key
+            "#{name}_id"
+        end
+
+        def primary_key(klass)
+          klass.primary_key || raise(UnknownPrimaryKey.new(klass))
+        end
+    end
+
+  end
+end