liquor 0.1.1 → 0.9.1

data/lib/liquor/diagnostics.rb

@@ -0,0 +1,151 @@
+module Liquor
+  class Diagnostic < StandardError
+    attr_reader :location
+    attr_reader :raw_message
+
+    def initialize(message, location=nil)
+      location_info = ""
+      if location
+        if location.include? :file
+          location_info << "`#{location[:file]}'"
+        end
+
+        if location.include? :line
+          location_info << ": line #{location[:line] + 1}"
+          if location.include? :start
+            location_info << ", column #{location[:start] + 1}"
+          end
+        end
+      end
+
+      @location    = location
+      @raw_message = message
+
+      if location_info.empty?
+        super(message)
+      else
+        super("#{message} at #{location_info}")
+      end
+    end
+
+    def error?
+      false
+    end
+
+    def decorate(source)
+      if @location && @location.has_key?(:line)
+        line   = source.lines.drop(@location[:line]).first
+        line ||= "(source spans only #{source.lines.count} lines)"
+        line   = line.rstrip
+
+        if @location.has_key? :start
+          start_col = tabify_column line, @location[:start]
+          pointer =  " " * start_col
+
+          if location.has_key? :end
+            end_col = tabify_column line, @location[:end]
+
+            pointer += "^" * (end_col - start_col + 1)
+          else
+            pointer += "^"
+          end
+        end
+      end
+
+      [ line, pointer ].compact
+    end
+
+    # Dammit, why should I replicate parts of VT-52 all over again?!
+    # Curse backwards compatibility and C.
+    def tabify_column(line, column)
+      display_column = 0
+
+      line[0...column].each_char do |char|
+        if char == "\t"
+          display_column += 8 - (display_column % 8)
+        else
+          display_column += 1
+        end
+      end
+
+      display_column
+    end
+
+    def as_json(options = nil)
+      {
+        message:  @raw_message,
+        is_error: error?,
+        location: @location,
+      }
+    end
+
+    def to_json(options = nil)
+      as_json.to_json(options)
+    end
+  end
+
+  class Error < Diagnostic
+    def error?
+      true
+    end
+  end
+
+  class SyntaxError < Error
+  end
+
+  class PartialError < Error
+  end
+
+  class ArgumentError < Error
+  end
+
+  class NameError < Error
+  end
+
+  class TypeError < Error
+  end
+
+  class ArgumentTypeError < Error
+    attr_reader :location
+
+    def initialize(message, location=nil)
+      location_info = ""
+      if location
+        if location.include? :function
+          location_info << "function `#{location[:function]}'"
+          if location.include? :argument
+            if location[:argument].nil?
+              location_info << ", unnamed argument"
+            else
+              location_info << ", argument `#{location[:argument]}'"
+            end
+          end
+        end
+      end
+
+      if location_info.empty?
+        super(message, location)
+      else
+        super("#{message} at #{location_info}", location)
+      end
+    end
+  end
+
+  class HostError < Error
+    attr_reader :original_error, :host_backtrace
+
+    def initialize(message, original_error, host_backtrace, location=nil)
+      @original_error = original_error
+      @host_backtrace = host_backtrace
+
+      if message.nil?
+        message = "#{original_error.class}: #{original_error.message}"
+      end
+
+      super(message, location)
+    end
+  end
+
+  class Deprecation < Diagnostic
+  end
+end

data/lib/liquor/drop/drop.rb

@@ -0,0 +1,168 @@
+require 'active_record'
+
+module Liquor
+  class Drop
+    include Liquor::External
+
+    attr_reader :source
+
+    def self.inherited(klass)
+      klass.instance_exec do
+        const_set :Scope, Class.new(::Liquor::Drop::Scope)
+        const_get(:Scope).instance_exec do
+          export # refresh liquor_exports
+        end
+      end
+    end
+
+    def initialize(source)
+      @source = source
+    end
+
+    def self.attributes(*attrs)
+      attrs.each do |attr|
+        define_method(attr) {
+          @source.send(attr)
+        }
+        export attr
+      end
+    end
+
+    def self.scopes(*scopes)
+      const_get(:Scope).instance_exec do
+        scopes.each do |scope|
+          define_method(scope) { |*args|
+            args = Drop.unwrap_scope_arguments(args)
+            DropDelegation.wrap_scope @source.send(scope, *args)
+          }
+          export scope
+        end
+      end
+    end
+
+    def self.unwrap_scope_arguments(args)
+      args.map do |arg|
+        case arg
+        when Drop
+          arg.id
+        when Drop::Scope
+          unwrap_scope_arguments(arg.to_a)
+        when Array
+          unwrap_scope_arguments(arg)
+        when Hash
+          Hash[arg.keys.zip(unwrap_scope_arguments(arg.values))]
+        else
+          arg
+        end
+      end
+    end
+
+    def self.define_singular_association_accessor(name, options={})
+      if options.has_key?(:if) && options.has_key?(:unless)
+        raise ArgumentError, "It is pointless to pass both :if and :unless conditions to has_one or belongs_to"
+      end
+
+      unsupported_options = (options.keys - [:if, :unless])
+      if unsupported_options.any?
+        raise ArgumentError, "Unsupported options #{unsupported_options.join(", ")}"
+      end
+
+      define_method(name) {
+        value = @source.send(name)
+
+        if self.class.check_singular_condition(value, options)
+          if value.nil?
+            nil
+          else
+            DropDelegation.wrap_element(value)
+          end
+        end
+      }
+
+      export name
+    end
+
+    def self.check_singular_condition(object, options)
+      execute = lambda do |object, condition|
+        if condition.is_a? Symbol
+          object.send(condition)
+        elsif condition.respond_to? :call
+          condition.(object)
+        else
+          raise ArgumentError, "Invalid condition type #{condition.class}"
+        end
+      end
+
+      if options[:if]
+        execute.(object, options[:if])
+      elsif options[:unless]
+        !execute.(object, options[:unless])
+      else
+        true
+      end
+    end
+
+    def self.belongs_to(name, options={})
+      define_singular_association_accessor(name, options)
+    end
+
+    def self.has_one(name, options={})
+      define_singular_association_accessor(name, options)
+    end
+
+    def self.has_many(name, options={})
+      unsupported_options = (options.keys - [:scope, :include])
+      if unsupported_options.any?
+        raise ArgumentError, "Unsupported options #{unsupported_options.join(", ")}"
+      end
+
+      define_method(name) {
+        value = @source.send(name)
+
+        if options[:scope]
+          # Sequentally apply each symbol from options[:scope]
+          # to the current scope, starting from `value' and using
+          # each result as current scope for the next operation.
+          value = Array(options[:scope]).reduce(value, &:send)
+        end
+
+        if options[:include]
+          Array(options[:include]).each do |collection|
+            value = value.includes(collection)
+          end
+        end
+
+        DropDelegation.wrap_scope(value, value.klass)
+      }
+
+      export name
+    end
+
+    def entity
+      @source.class.model_name.to_s
+    end
+    export :entity
+
+    def ==(other)
+      if other.is_a? Liquor::Drop
+        self.source == other.source
+      else
+        other == self
+      end
+    end
+
+    alias eql? ==
+
+    def hash
+      @source.hash
+    end
+
+    def to_drop
+      self
+    end
+  end
+end
+
+require_relative 'drop_delegation'
+require_relative 'drop_scope'
+require_relative 'dropable'

data/lib/liquor/drop/drop_delegation.rb

@@ -0,0 +1,24 @@
+module Liquor
+  module DropDelegation
+    # aka module_method for every method.
+    extend self
+
+    def wrap_scope(scope, klass=scope)
+      drop_klass = "#{klass.name}Drop::Scope".constantize
+      drop_klass.new(scope)
+    end
+
+    def wrap_element(element)
+      unless element.nil?
+        drop_klass = "#{element.class.name}Drop".constantize
+        drop_klass.new(element)
+      end
+    end
+
+    def unwrap_drop_class(klass)
+      drop_klass_name  = klass.name
+      model_class_name = drop_klass_name.sub(/Drop$/, '')
+      model_class_name.constantize
+    end
+  end
+end

data/lib/liquor/drop/drop_scope.rb

@@ -0,0 +1,118 @@
+module Liquor
+  class Drop::Scope
+    include Liquor::External
+
+    attr_reader :source
+
+    def initialize(source)
+      unless source.respond_to? :each
+        source = source.all
+      end
+
+      @source = source
+    end
+
+    # Not exported.
+    def to_a
+      @source.map do |elem|
+        DropDelegation.wrap_element(elem)
+      end
+    end
+    alias to_ary to_a
+
+    def entity
+      @source.model_name.to_s
+    end
+    export :entity
+
+    def find_by(_, fields={})
+      fields, = Drop.unwrap_scope_arguments([ fields ])
+
+      result = @source.where(fields).first
+      DropDelegation.wrap_element result if result
+    end
+
+    def find_all_by(_, fields={})
+      fields, = Drop.unwrap_scope_arguments([ fields ])
+
+      result = @source.where(fields)
+      DropDelegation.wrap_scope(result)
+    end
+
+    export :find_all_by, :find_by
+
+    def except(record)
+      record, = Drop.unwrap_scope_arguments([ record ])
+
+      result = @source.where(@source.arel_table[:id].eq(record).not)
+      DropDelegation.wrap_scope(result)
+    end
+
+    def find_except_by(_, fields={})
+      fields, = Drop.unwrap_scope_arguments([ fields ])
+
+      result = @source.
+        where(fields.map do |key, value|
+          @source.arel_table[key].eq(value)
+        end.reduce(&:and).not)
+      DropDelegation.wrap_scope(result)
+    end
+
+    export :except, :find_except_by
+
+    def first
+      DropDelegation.wrap_element @source.first
+    end
+
+    def last
+      DropDelegation.wrap_element @source.last
+    end
+
+    def [](index)
+      DropDelegation.wrap_element @source[index]
+    end
+
+    # Not exported. No block support in Liquor.
+    def each
+      @source.each do |elem|
+        yield DropDelegation.wrap_element(elem)
+      end
+    end
+
+    # Not exported. No ? in names in Liquor.
+    def include?(elem)
+      if elem.is_a? Liquor::Drop
+        @source.include? elem.source
+      else
+        false
+      end
+    end
+
+    def pluck(attribute)
+      @source.map do |elem|
+        DropDelegation.wrap_element(elem).liquor_send(attribute.to_s, [])
+      end
+    end
+
+    def count
+      @source.count
+    end
+    alias size count # for builtin compatibility
+
+    export :first, :last, :[], :pluck
+
+    def limit(count)
+      DropDelegation.wrap_scope @source.limit(count)
+    end
+
+    def offset(count)
+      DropDelegation.wrap_scope @source.offset(count)
+    end
+
+    def reverse
+      DropDelegation.wrap_scope @source.reverse_order
+    end
+
+    export :limit, :offset, :reverse
+  end
+end