fzip 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OTg0MWE1NTE4M2IyYmVjN2UxZjQ1NGM4YTdjNTQwZTAxNzkzOWQ5NQ==
+  data.tar.gz: !binary |-
+    ZTg4YWE1NWIxMDViZDA3YThiZDliYTI3MjY0MTQ2YTU5Nzc2MmI0YQ==
+SHA512:
+  metadata.gz: !binary |-
+    MmRiYzljMTVhNzhmNDk0MDdlZTZmOTViNTIyZmZjM2FhZTBkZjZmYmUzNTlm
+    ZTA0NWU5ZDYyNDhjNmY0YWNhYjA5MzBhNjc1NzJhZTA0MzgxZTc0NzVhMzRm
+    MDE0NjcyYjI0ZDAyZjVkMWJiZmU1ZThjNWZiNjFmZDU5NjViNDg=
+  data.tar.gz: !binary |-
+    NTQwZDkzMzVmYWYzMzRjYWI1OGIwMzUzODEyN2U4MzFlZmJhNGJiODBmMDg2
+    YmNlNWIyYzM4ZjA5M2VkMzhjODA5MzYxZmM1MWMxZDAwNTZkNjg3ODRkM2Iw
+    MzAyYmVlYjhiNWY3ZTMzYmVjMjI2YjAyMmNhNDQ0ZmM2OWY1ZDg=

data/.gitignore

@@ -0,0 +1 @@
+coverage

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2013-2014 Arne Brasseur
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,33 @@
+# Fzip : Functional zippers for Ruby
+
+To traverse and alter a hierarchical data structure in a functional way is best done using the "zipper" data structure as described originally by [Huet](http://www.st.cs.uni-saarland.de/edu/seminare/2005/advanced-fp/docs/huet-zipper.pdf).
+
+`Fzip::Zipper` is a straight up port of the Clojure zip/zip library.
+
+The Zipper can work with arbitrary hierarchical objects (trees). To do that it requires an adapter that implements three methods: `branch?(node)`, `children(node)`, and `create_node(node, children)`. An implementation for nested arrays is provided.
+
+```ruby
+zipper = Fzip.array(
+  [
+    ['x', '+', 'y'],
+    '=',
+    ['a', '/', 'b']
+  ]
+)
+
+p zipper.down.right.right.down.right.replace(:foo).root
+# >> [["x", "+", "y"], "=", ["a", :foo, "b"]]
+
+p zipper.down.append_child(:bar).root
+# >> [["x", "+", "y", :bar], "=", ["a", "/", "b"]]
+
+p zipper.down.insert_child(:bar).down.right.insert_right(:baz).up.insert_left(:quux).root
+# >> [:quux, [:bar, "x", :baz, "+", "y"], "=", ["a", "/", "b"]]
+```
+
+## Further reading
+
+* [Wikipedia: Zipper (data structure)](https://en.wikipedia.org/wiki/Zipper_%28data_structure%29)
+* [Three part article](http://pavpanchekha.com/blog/zippers/huet.html)
+
+The Wikipedia page has more interesting links.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rubygems/package_task'
+
+spec = Gem::Specification.load(File.expand_path('../fzip.gemspec', __FILE__))
+gem = Gem::PackageTask.new(spec)
+gem.define
+
+desc "Push gem to rubygems.org"
+task :push => :gem do
+  sh "git tag v#{Fzip::VERSION}"
+  sh "git push --tags"
+  sh "gem push pkg/fzip-#{Fzip::VERSION}.gem"
+end

data/fzip.gemspec

@@ -0,0 +1,20 @@
+require File.expand_path('../lib/fzip/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = 'fzip'
+  gem.version     = '0.1.0'
+  gem.authors     = [ 'Arne Brasseur' ]
+  gem.email       = [ 'arne@arnebrasseur.net' ]
+  gem.description = 'Functional zipper class'
+  gem.summary     = gem.description
+  gem.homepage    = 'https://github.com/plexus/fzip'
+  gem.license     = 'MIT'
+
+  gem.require_paths    = %w[lib]
+  gem.files            = `git ls-files`.split($/)
+  gem.test_files       = `git ls-files -- spec`.split($/)
+  gem.extra_rdoc_files = %w[README.md]
+
+  gem.add_development_dependency 'rake', '~> 10.1'
+  gem.add_development_dependency 'rspec', '~> 2.14'
+end

data/lib/fzip/adapter.rb

@@ -0,0 +1,12 @@
+module FZip
+  class Adapter
+    def branch?(node)
+    end
+
+    def children(node)
+    end
+
+    def make_node(node, children)
+    end
+  end
+end

data/lib/fzip/array_adapter.rb

@@ -0,0 +1,16 @@
+module Fzip
+  class ArrayAdapter
+    def branch?(node)
+      node.respond_to? :to_ary
+    end
+
+    def children(node)
+      node.empty? ? nil : node
+    end
+
+    def make_node(node, children)
+      children
+    end
+
+  end
+end

data/lib/fzip/version.rb

@@ -0,0 +1,3 @@
+module Fzip
+  VERSION = '0.1.0'
+end

data/lib/fzip/zipper.rb

@@ -0,0 +1,167 @@
+module Fzip
+  class Zipper
+    attr_reader :adapter, :parent, :path, :node, :lefts, :rights, :at_end
+
+    def initialize(adapter, node, lefts = nil, path = nil, parent = nil, rights = nil, changed = false, at_end = false)
+      @adapter   = adapter
+      @node      = node
+      @lefts     = lefts
+      @path      = path
+      @parent    = parent
+      @rights    = rights
+      @changed   = changed
+      @at_end    = at_end
+    end
+
+    def new(changes = {})
+      self.class.new(
+        @adapter,
+        changes.fetch(:node)    { self.node     },
+        changes.fetch(:lefts)   { self.lefts    },
+        changes.fetch(:path)    { self.path     },
+        changes.fetch(:parent)  { self.parent   },
+        changes.fetch(:rights)  { self.rights   },
+        changes.fetch(:changed) { self.changed? },
+        changes.fetch(:end)     { self.end?     }
+      )
+    end
+
+    def branch?
+      adapter.branch?(node)
+    end
+
+    def children
+      raise "called children on a leaf node" unless branch?
+      @cs ||= adapter.children(node)
+    end
+
+    def make_node(node, children)
+      adapter.make_node(node, children)
+    end
+
+    def changed?
+      @changed
+    end
+
+    def end?
+      @at_end
+    end
+
+    def down
+      if branch? && children
+        new(
+          node: children.first,
+          lefts: [],
+          path: path ? [node] + path : [node],
+          parent: self,
+          rights: children.drop(1)
+        )
+      end
+    end
+
+    def up
+      if path
+        return parent unless changed?
+        parent_path = path.drop(1)
+        new(
+          node:   make_node(node, lefts + [node] + rights),
+          lefts:  parent.lefts,
+          path:   parent_path.empty? ? nil : parent_path,
+          parent: parent.parent,
+          rights: parent.rights
+        )
+      end
+    end
+
+    def root
+      return node unless path
+      up.root
+    end
+
+    def right
+      if path && rights && !rights.empty?
+        new(
+          node:   rights.first,
+          lefts:  lefts + [node],
+          rights: rights.drop(1)
+        )
+      end
+    end
+
+    #def rightmost
+
+    def left
+      if path && lefts && !lefts.empty?
+        new(
+          node:   lefts.last,
+          lefts:  lefts[0...-1],
+          rights: [node] + rights
+        )
+      end
+    end
+
+    # def leftmost
+
+    def insert_left(item)
+      raise "insert at top" unless path
+      new(
+        lefts:   lefts + [item],
+        changed: true
+      )
+    end
+
+    def insert_right(item)
+      raise "insert at top" unless path
+      new(
+        rights:  [item] + rights,
+        changed: true
+      )
+    end
+
+    def replace(item)
+      new(
+        node: item,
+        changed: true
+      )
+    end
+
+    def edit
+      replace(yield node)
+    end
+
+    def insert_child(item)
+      replace(make_node(node, [item] + children))
+    end
+
+    def append_child(item)
+      replace(make_node(node, children + [item]))
+    end
+
+    def next
+      backtrack = ->(node) {
+        if node.up
+          node.up.right || backtrack.(node.up)
+        else
+          node.new(end: true)
+        end
+      }
+
+      (self if end?) ||
+        (branch? && down) ||
+        right ||
+        backtrack.(self)
+    end
+
+    # def prev
+
+    # def remove
+
+    def each
+      return to_enum unless block_given?
+      loc = self
+      until (loc = loc.next).end?
+        yield loc
+      end
+    end
+  end
+end

data/lib/fzip.rb

@@ -0,0 +1,9 @@
+
+module Fzip
+  def self.array(node)
+    Zipper.new(ArrayAdapter.new, node)
+  end
+end
+
+require_relative 'fzip/array_adapter'
+require_relative 'fzip/zipper'

data/spec/fzip_spec.rb

@@ -0,0 +1,34 @@
+$LOAD_PATH.unshift(Pathname(__FILE__).dirname.parent.join('lib'))
+
+require 'fzip'
+
+describe Fzip, 'array' do
+  let(:tree) {
+    [
+      ['x', '+', 'y'],
+      ['a', '*', 'b']
+    ]
+  }
+
+  let(:zipper) { Fzip.array(tree) }
+
+  it 'should return a zipper suitable for arrays' do
+    expect(zipper.adapter).to be_an_instance_of(Fzip::ArrayAdapter)
+  end
+
+  it 'should allow navigating' do
+    expect(zipper.down.down.right.right.left.node).to eq('+')
+  end
+
+  it 'should allow inserting nodes' do
+    expect(zipper.down.down.right.insert_left(:foo).insert_right(:bar).root).to eq [["x", :foo, "+", :bar, "y"], ["a", "*", "b"]]
+  end
+
+  it 'should allow replacing nodes' do
+    expect(zipper.down.right.down.right.replace(:foo).root).to eq [["x", "+", "y"], ["a", :foo, "b"]]
+  end
+
+  it 'should allow editing with a block' do
+    expect(zipper.down.right.down.right.edit{:foo}.root).to eq [["x", "+", "y"], ["a", :foo, "b"]]
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: fzip
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Arne Brasseur
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+- !ruby/object:Gem::Dependency
+  prerelease: false
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+description: Functional zipper class
+email:
+- arne@arnebrasseur.net
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- fzip.gemspec
+- lib/fzip.rb
+- lib/fzip/adapter.rb
+- lib/fzip/array_adapter.rb
+- lib/fzip/version.rb
+- lib/fzip/zipper.rb
+- spec/fzip_spec.rb
+homepage: https://github.com/plexus/fzip
+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.1
+signing_key: 
+specification_version: 4
+summary: Functional zipper class
+test_files:
+- spec/fzip_spec.rb