destructure 0.0.12

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d1c33debe9be83eab196be5c71b8602b4467a0e
+  data.tar.gz: d28c21e0de1f1ddd88bbfa73a858025375f13fba
+SHA512:
+  metadata.gz: d4266394d4d8ee34872c810c777ca1882a43f6cc1d769f62855ef8e5eb16e38b4a3cf10c09ee1a0c7418932e6faba1a2eb6fa226b08a3ea4952b3217158e38bb
+  data.tar.gz: 52ede93459670e44d1407263210267aedae88a6a69f184fb271e24ef709b5148675f251644e34ccc02b00bd94b2cd7584ccb12eaa3eb63773fd1f44aa5f8f802

data/lib/destructure.rb

@@ -0,0 +1 @@
+require_relative './destructure/destructure'

data/lib/destructure/destructure.rb

@@ -0,0 +1,90 @@
+require 'sourcify'
+require 'active_support/inflector'
+require 'paramix'
+require 'binding_of_caller'
+require 'destructure/dmatch'
+require 'destructure/sexp_transformer'
+
+module Destructure
+
+  include Paramix::Parametric
+
+  parameterized do |params|
+
+    private :bind_locals do
+      bind = params[:bind_locals]
+      @bind_locals ||= bind.nil? ? true : bind
+    end
+
+    if params[:env_name]
+      private params[:env_name] do
+        @_my_destructure_env
+      end
+      private :set_custom_env do |value|
+        @_my_destructure_env = value
+      end
+    end
+
+    if params[:matcher_name]
+      private params[:matcher_name] do |&pattern|
+        proc { |x| dbind(x, &pattern) }
+      end
+    end
+  end
+
+  def dbind(x, &pat_block)
+    dbind_internal(x, pat_block.to_sexp(strip_enclosure: true, ignore_nested: true), binding.of_caller(1), caller_locations(1,1)[0].label)
+  end
+
+  private ########################################
+
+  def bind_locals
+    true
+  end
+
+  def dbind_internal(x, sexp, caller_binding, caller_location)
+    env = dbind_no_ostruct_sexp(x, sexp, caller_binding)
+    return nil if env.nil?
+
+    if bind_locals
+      env.keys.each {|k| _destructure_set(k.name, env[k], caller_binding, caller_location)}
+    end
+
+    ostruct_env = env.to_openstruct
+    set_custom_env(ostruct_env) if self.respond_to?(:set_custom_env, true)
+    ostruct_env
+  end
+
+  def dbind_no_ostruct_sexp(x, sexp, caller_binding)
+    sp = sexp
+    pat = SexpTransformer.transform(sp, caller_binding)
+    DMatch::match(pat, x)
+  end
+
+  def _destructure_set(name, value, binding, caller)
+    if name.is_a?(String) || binding.eval("defined? #{name}") == 'local-variable'
+      $binding_temp = value
+      binding.eval("#{name} = $binding_temp")
+    else
+      if binding.eval('self').respond_to?(name, true)
+        raise "Cannot have pattern variable named '#{name}'. A method already exists with that name. Choose a different name, " +
+                  "or pre-initialize a local variable that shadows the method."
+      end
+      @_destructure_env ||= {}
+      @_destructure_env[caller] ||= {}
+      @_destructure_env[caller][name] = value
+    end
+  end
+
+  def method_missing(name, *args, &block)
+    if bind_locals
+      c = caller_locations(1,1)[0].label
+      @_destructure_env ||= {}
+      caller_hash = @_destructure_env[c]
+      caller_hash && caller_hash.keys.include?(name) ? caller_hash[name] : super
+    else
+      super
+    end
+  end
+
+end

data/lib/destructure/dmatch.rb

@@ -0,0 +1,160 @@
+require 'destructure/env'
+require 'destructure/types'
+
+class DMatch
+  def self.match(pat, x)
+    DMatch.new(Env.new).match(pat, x)
+  end
+
+  def self._
+    Wildcard.instance
+  end
+
+  def initialize(env)
+    @env = env
+  end
+
+  def match(pat, x)
+    case
+      when pat.is_a?(Wildcard); @env
+      when pat.is_a?(Pred) && pat.test(x, @env); @env
+      when pat.is_a?(FilterSplat); match_filter_splat(pat, x)
+      when pat.is_a?(SelectSplat); match_select_splat(pat, x)
+      when pat.is_a?(Splat); match_splat(pat, x)
+      when pat.is_a?(Var) && pat.test(x, @env); match_var(pat, x)
+      when pat.is_a?(Obj) && pat.test(x, @env) && all_field_patterns_match(pat, x); @env
+      when pat.is_a?(String) && pat == x; @env
+      when pat.is_a?(Regexp); match_regexp(pat, x)
+      when pat.is_a?(Or); match_or(pat, x)
+      when hash(pat, x) && all_keys_match(pat, x); @env
+      when enumerable(pat, x); match_enumerable(pat, x)
+      when pat == x; @env
+      else; nil
+    end
+  end
+
+  private ###########################################################
+
+  def all_keys_match(pat, x)
+    all_match(pat.keys.map { |k| x.keys.include?(k) && match(pat[k], x[k]) })
+  end
+
+  def match_regexp(pat, x)
+    m = pat.match(x)
+    m && @env.merge!(Hash[pat.named_captures.keys.map { |k| [Var.new(k.to_sym), m[k]] }])
+  end
+
+  def all_field_patterns_match(pat, x)
+    all_match(pat.fields.keys.map { |name| x.respond_to?(name) && match(pat.fields[name], x.send(name)) })
+  end
+
+  def match_var(pat, x)
+    @env.bind(pat, x)
+  end
+
+  def match_or(pat, x)
+    pat.patterns.lazy.map{|p| match(p, x)}.reject{|e| e.nil?}.first
+  end
+
+  def match_splat(pat, x)
+    @env.bind(pat, enumerable(x) ? x : [x])
+  end
+
+  def match_select_splat(pat, x)
+    x_match_and_env = x.map { |z| [z, DMatch::match(pat.pattern, z)] }.reject { |q| q.last.nil? }.first
+    if x_match_and_env
+      x_match, env = x_match_and_env
+      @env.bind(pat, x_match) && @env.merge!(env)
+    else
+      nil
+    end
+  end
+
+  def match_filter_splat(pat, x)
+    @env.bind(pat, x.map { |z| [z, match(pat.pattern, z)] }.reject { |q| q.last.nil? }.map { |q| q.first })
+  end
+
+  def match_enumerable(pat, x)
+    case
+      when (parts = decompose_splatted_enumerable(pat))
+        pat_before, pat_splat, pat_after = parts
+        x_before = x.take(pat_before.length)
+        if pat_after.any?
+          splat_len = len(x) - pat_before.length - pat_after.length
+          return nil if splat_len < 0
+          x_splat = x.drop(pat_before.length).take(splat_len)
+        else
+          x_splat = x.drop(pat_before.length)
+        end
+
+        before_and_splat_result = match_enumerable_no_splats(pat_before, x_before) && match(pat_splat, x_splat)
+
+        if before_and_splat_result && pat_after.any?
+          # do this only if we have to, since it requires access to the end of the enumerable,
+          # which doesn't work with infinite enumerables
+          x_after = take_last(pat_after.length, x)
+          match_enumerable_no_splats(pat_after, x_after)
+        else
+          before_and_splat_result
+        end
+      when len(pat) == len(x)
+        match_enumerable_no_splats(pat, x)
+      else; nil
+    end
+  end
+
+  def decompose_splatted_enumerable(pat)
+    before = []
+    splat = nil
+    after = []
+    pat.each do |p|
+      case
+        when p.is_a?(Splat)
+          if splat.nil?
+            splat = p
+          else
+            raise "cannot have more than one splat in a single array: #{pat.inspect}"
+          end
+        when splat.nil?
+          before.push(p)
+        else
+          after.push(p)
+      end
+    end
+
+    splat && [before, splat, after]
+  end
+
+  def take_last(n, xs)
+    result = []
+    xs.reverse_each do |x|
+      break if result.length == n
+      result.unshift x
+    end
+    result
+  end
+
+  def len(x)
+    x.respond_to?(:length) ? x.length : x.count
+  end
+
+  def match_enumerable_no_splats(pat, x)
+    all_match(pat.zip(x).map{|a| match(*a)}) ? @env : nil
+  end
+
+  def enumerable(*xs)
+    xs.all?{|x| x.is_a?(Enumerable)}
+  end
+
+  def hash(*xs)
+    xs.all?{|x| x.is_a?(Hash)}
+  end
+
+  def all_match(xs)
+    xs.all?{|x| x.is_a?(Env)}
+  end
+
+  class Wildcard
+    include Singleton
+  end
+end

data/lib/destructure/env.rb

@@ -0,0 +1,49 @@
+require 'ostruct'
+require 'destructure/dmatch'
+require 'destructure/types'
+
+class DMatch
+  class Env
+
+    def env
+      @env ||= {}
+    end
+
+    def [](identifier)
+      raise 'identifier must be a Var or symbol' unless (identifier.is_a? Var) || (identifier.is_a? Symbol)
+      if identifier.is_a? Symbol
+        identifier = env.keys.select{|k| k.name == identifier}.first || identifier
+      end
+      v = env[identifier]
+      raise "Identifier '#{identifier}' is not bound." if v.nil?
+      v.is_a?(EnvNil) ? nil : v
+    end
+
+    def bind(identifier, value)
+      raise 'identifier must be a Var' unless identifier.is_a? Var
+      value_to_store = value.nil? ? EnvNil.new : value
+      existing_key = env.keys.select{|k| k == identifier || (k.name.is_a?(Symbol) && k.name == identifier.name)}.first
+      return nil if existing_key &&
+          (DMatch.match(env[existing_key], value_to_store).nil? ||
+          DMatch.match(value_to_store, env[existing_key]).nil?)
+      env[existing_key || identifier] = value_to_store
+      self
+    end
+
+    alias []= bind
+
+    def keys
+      env.keys
+    end
+
+    def to_openstruct
+      OpenStruct.new(Hash[env.map{|kv| [kv.first.name, kv.last]}])
+    end
+
+    def merge!(other_env)
+      other_env.keys.any?{|k| bind(k, other_env[k]).nil?} ? nil : self
+    end
+
+    class EnvNil; end
+  end
+end

data/lib/destructure/magic.rb

@@ -0,0 +1,26 @@
+require 'destructure/destructure'
+
+module DestructureMagic
+  def self.included(base)
+    orig = base.instance_method(:=~)
+
+    base.send(:define_method, :=~) do |pattern|
+      if pattern.is_a?(Regexp)
+        orig.bind(self).call(pattern)
+      elsif pattern.is_a?(Proc)
+        # stuff gets cranky if you try to factor this out
+        caller_binding = binding.of_caller(1)
+        caller_location = caller_locations(1,1)[0].label
+        caller = caller_binding.eval('self')
+        caller.class.send(:include, Destructure) unless caller.class.included_modules.include?(Destructure)
+        caller.send(:dbind_internal, self, pattern.to_sexp(strip_enclosure: true, ignore_nested: true), caller_binding, caller_location)
+      else
+        super
+      end
+    end
+  end
+end
+
+class Object; include DestructureMagic end
+class String; include DestructureMagic end
+class Symbol; include DestructureMagic end

data/lib/destructure/sexp_transformer.rb

@@ -0,0 +1,156 @@
+require 'active_support/inflector'
+require 'destructure/dmatch'
+
+module Destructure
+  class SexpTransformer
+
+    def self.transform(sp, caller_binding)
+      SexpTransformer.new(caller_binding).transform(sp)
+    end
+
+    def initialize(caller_binding)
+      @caller_binding = caller_binding
+    end
+
+    def transform(sp)
+      _ = DMatch::_
+      klass_sym = DMatch::Var.new(&method(:is_constant?))
+      case
+        # '_' (wildcard)
+        when e = dmatch([:call, _, :_, _], sp); _
+        # object matcher without parameters
+        when e = dmatch([:const, klass_sym], sp)
+          make_obj(e[klass_sym], {})
+        # '~' (splat)
+        when e = dmatch([:call, var(:identifier_sexp), :~, [:arglist]], sp); splat(unwind_receivers_and_clean(e[:identifier_sexp]))
+        # '!' (variable value)
+        when e = dmatch([:not, var(:value_sexp)], sp)
+          @caller_binding.eval(unwind_receivers_and_clean(e[:value_sexp]).to_s)
+        # '|' (alternative patterns)
+        when e = dmatch([:call, var(:rest), :|, [:arglist, var(:alt)]], sp); DMatch::Or.new(*[e[:rest], e[:alt]].map(&method(:transform)))
+        # generic call
+        when e = dmatch([:call, var(:receiver), var(:msg), var(:arglist)], sp)
+          transform_call(e[:receiver], e[:msg], e[:arglist])
+        # instance variable
+        when e = dmatch([:ivar, var(:name)], sp); var(e[:name].to_s)
+        # let
+        # ... with local or instance vars
+        when e = dmatch([DMatch::Or.new(:lasgn, :iasgn), var(:lhs), var(:rhs)], sp)
+          let_var(e[:lhs], transform(e[:rhs]))
+        # ... with attributes or something more complicated
+        when e = dmatch([:attrasgn, var(:obj), var(:attr), [:arglist, var(:rhs)]], sp)
+          var_name = unwind_receivers_and_clean([:call, e[:obj], e[:attr].to_s.sub(/=$/,'').to_sym, [:arglist]])
+          let_var(var_name, transform(e[:rhs]))
+        # literal values
+        when e = dmatch([:lit, var(:value)], sp); e[:value]
+        when e = dmatch([:true], sp); true
+        when e = dmatch([:false], sp); false
+        when e = dmatch([:nil], sp); nil
+        when e = dmatch([:str, var(:s)], sp); e[:s]
+        when e = dmatch([:array, splat(:items)], sp); e[:items].map(&method(:transform))
+        when e = dmatch([:hash, splat(:kvs)], sp); Hash[*e[:kvs].map(&method(:transform))]
+        else; raise "Unexpected sexp: #{sp.inspect}"
+      end
+    end
+
+    private ########################################
+
+    def transform_call(*sexp_call)
+      sexp_receiver, sexp_msg, sexp_args = sexp_call
+      _ = DMatch::_
+      klass_sym_var = DMatch::Var.new(&method(:is_constant?))
+      case
+        # Class[...]
+        when e = dmatch([[:const, klass_sym_var], :[]], [sexp_receiver, sexp_msg])
+          field_map = make_field_map(sexp_args)
+          klass_sym = e[klass_sym_var]
+          klass_sym == :Hash ? field_map : make_obj(klass_sym, field_map)
+        # local variable
+        when e = dmatch([nil, var(:name), [:arglist]], sexp_call); var(e[:name])
+        # call chain (@one.two(12).three[3].four)
+        else; var(unwind_receivers_and_clean([:call, *sexp_call]))
+      end
+    end
+
+    def make_field_map(sexp_args)
+      case
+        # Class[a: 1, b: 2]
+        when e = dmatch([:arglist, [:hash, splat(:kv_sexps)]], sexp_args)
+          kvs = transform_many(e[:kv_sexps])
+          Hash[*kvs]
+        # Class[a, b, c]
+        when e = dmatch([:arglist, splat(:field_name_sexps)], sexp_args)
+          field_names = transform_many(e[:field_name_sexps])
+          Hash[field_names.map { |f| [f.name, var(f.name)] }]
+        else; raise 'oops'
+      end
+    end
+
+    def unwind_receivers_and_clean(receiver)
+      unwound = unwind_receivers(receiver).gsub(/\.$/, '').gsub(/\.\[/, '[')
+      identifier?(unwound) ? unwound.to_sym : unwound
+    end
+
+    def identifier?(x)
+      x =~ /^[_a-zA-Z][_0-9a-zA-Z]*$/
+    end
+
+    def unwind_receivers(receiver)
+      to_s
+      case
+        when receiver.nil?; ''
+        when e = dmatch([:lit, var(:value)], receiver); "#{e[:value]}."
+        when e = dmatch([:ivar, var(:name)], receiver); "#{e[:name]}."
+        when e = dmatch([:call, var(:receiver), :[], [:arglist, splat(:args)]], receiver)
+          unwind_receivers(e[:receiver]) + format_hash_call(e[:args])
+        when e = dmatch([:call, var(:receiver), var(:msg), [:arglist, splat(:args)]], receiver)
+          unwind_receivers(e[:receiver]) + format_method_call(e[:msg], e[:args])
+        else; raise 'oops'
+      end
+    end
+
+    def format_method_call(msg, args)
+      "#{msg}(#{transform_args(args)})".gsub(/\(\)$/, '') + '.'
+    end
+
+    def format_hash_call(args)
+      "[#{transform_args(args)}].".gsub(/\(\)$/, '')
+    end
+
+    def transform_args(args)
+      transform_many(args).map { |x| x.is_a?(Symbol) ? ":#{x}" : x.to_s }.join(', ')
+    end
+
+    def transform_many(xs)
+      xs.map(&method(:transform))
+    end
+
+    def make_obj(klass_sym, field_map)
+      DMatch::Obj.of_type(klass_sym.to_s.constantize, field_map)
+    end
+
+    def is_constant?(x, env=nil)
+      x.is_a?(Symbol) && is_uppercase?(x.to_s[0])
+    end
+
+    def is_uppercase?(char)
+      char == char.upcase
+    end
+
+    def dmatch(*args)
+      DMatch::match(*args)
+    end
+
+    def var(name)
+      DMatch::Var.new(name)
+    end
+
+    def let_var(name, pattern)
+      DMatch::Var.new(name) { |x, env| DMatch.new(env).match(pattern, x) }
+    end
+
+    def splat(name)
+      DMatch::Splat.new(name)
+    end
+  end
+end

data/lib/destructure/types.rb

@@ -0,0 +1,90 @@
+require 'singleton'
+
+module Predicated
+
+  def test(x, env=nil)
+    @pred == nil ? true : @pred.call(x, env)
+  end
+
+  private
+  attr_accessor :pred
+
+end
+
+class DMatch
+
+  class Var
+    include Predicated
+
+    attr_reader :name
+
+    def initialize(name=nil, &pred)
+      @name = name
+      self.pred = pred
+    end
+  end
+
+  class Splat < Var; end
+
+  # experimental
+  class FilterSplat < Splat
+    attr_reader :pattern
+
+    def initialize(name=nil, pattern)
+      super(name)
+      @pattern = pattern
+      validate_pattern
+    end
+
+    def validate_pattern
+      raise 'FilterSplat pattern cannot contain variables' if @pattern.flatten.any?{|p| p.is_a?(Var)}
+    end
+  end
+
+  # experimental
+  class SelectSplat < Splat
+    attr_reader :pattern
+
+    def initialize(name=nil, pattern)
+      super(name)
+      @pattern = pattern
+    end
+  end
+
+  class Obj
+    include Predicated
+
+    attr_reader :fields
+
+    def initialize(fields={}, &pred)
+      @fields = fields
+      self.pred = pred
+    end
+
+    def self.of_type(klass, fields={}, &pred)
+      Obj.new(fields) {|x| x.is_a?(klass) && (!pred || pred.call(x))}
+    end
+  end
+
+  class Pred
+    include Predicated
+
+    def initialize(pred_callable=nil, &pred_block)
+      raise 'Cannot specify both a callable and a block' if pred_callable && pred_block
+      self.pred = pred_callable || pred_block
+    end
+  end
+
+  class Or
+    attr_reader :patterns
+    def initialize(*patterns)
+      @patterns = flatten(patterns)
+    end
+
+    private
+
+    def flatten(ps)
+      ps.inject([]) {|acc, p| p.is_a?(Or) ? acc + p.patterns : acc << p}
+    end
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: destructure
+version: !ruby/object:Gem::Version
+  version: 0.0.12
+platform: ruby
+authors:
+- Peter Winton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sourcify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0.rc4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0.rc4
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: binding_of_caller
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.2
+- !ruby/object:Gem::Dependency
+  name: paramix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.1
+description: Destructuring assignment in Ruby
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/destructure.rb
+- lib/destructure/destructure.rb
+- lib/destructure/dmatch.rb
+- lib/destructure/env.rb
+- lib/destructure/magic.rb
+- lib/destructure/sexp_transformer.rb
+- lib/destructure/types.rb
+homepage: http://rubygems.org/gems/destructure
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Destructuring assignment in Ruby
+test_files: []