ciphr 0.0.2 → 0.0.4

data/lib/ciphr/stream.rb

@@ -1,49 +1,49 @@
-module Ciphr
-  class Stream
-    def initialize(reader)
-      @reader = reader
-      @buffer = ""
-      @eof = false
-    end
-
-    def read(n=nil) #fix this
-      if n
-        init
-        while @buffer.size < n && !@eof 
-          fill
-        end
-        if @buffer.size > 0
-          ret = @buffer[0,n]
-          @buffer = @buffer[n..-1] || ''
-        else 
-          ret = nil
-        end
-        ret
-      else
-        buff = ""
-        while chunk=read(256)
-          buff+=chunk
-        end
-        buff 
-      end
-    end
-
-    def prepend(str)
-      @buffer = str + @buffer
-    end
-
-    private
-      def fill
-        data = @reader.call
-        @eof = true if !data
-        @buffer = @buffer + data if data
-      end
-
-      def init #hack
-        if !@init
-          @init = true
-          @reader = @reader.apply if @reader.respond_to?(:apply)
-        end
-      end
-  end
-end
+module Ciphr
+  class Stream
+    def initialize(reader)
+      @reader = reader
+      @buffer = ""
+      @eof = false
+    end
+
+    def read(n=nil) #fix this
+      if n
+        init
+        while @buffer.size < n && !@eof 
+          fill
+        end
+        if @buffer.size > 0
+          ret = @buffer[0,n]
+          @buffer = @buffer[n..-1] || ''
+        else 
+          ret = nil
+        end
+        ret
+      else
+        buff = ""
+        while chunk=read(256)
+          buff+=chunk
+        end
+        buff 
+      end
+    end
+
+    def prepend(str)
+      @buffer = str + @buffer
+    end
+
+    private
+      def fill
+        data = @reader.call
+        @eof = true if !data
+        @buffer = @buffer + data if data
+      end
+
+      def init #hack
+        if !@init
+          @init = true
+          @reader = @reader.apply if @reader.respond_to?(:apply)
+        end
+      end
+  end
+end

data/lib/ciphr/version.rb

@@ -1,3 +1,3 @@
 module Ciphr
-  VERSION = "0.0.2"
+  VERSION = "0.0.4"
 end

data/spec/ciphr_spec.rb

@@ -1,21 +1,21 @@
-require 'spec_helper'
-require 'ciphr'
-
-describe Ciphr do
-  describe :transform do
-    it "works for some simple test cases" do
-        Ciphr.transform("md5 hex","").should be == "d41d8cd98f00b204e9800998ecf8427e"
-        Ciphr.transform("b64 ~b64","foobar").should be == "foobar"
-        Ciphr.transform("b2 b16 ~b16 ~b2","foobar").should be == "foobar"
-        Ciphr.transform('"foobar"',"").should be == "foobar"
-        Ciphr.transform('=ABBB b64',"").should be == "ABBB"        
-        Ciphr.transform('0x41',"").should be == "A"
-        Ciphr.transform('0b01000001',"").should be == "A"
-        Ciphr.transform('0x43 xor[0x01]',"").should be == "B"
-        Ciphr.transform('0x4343 xor[0x01]',"").should be == "BB"
-        Ciphr.transform('0x01 xor[0x4343]',"").should be == "BB"
-        Ciphr.transform('0x00 url', "").should be == '%00'
-        Ciphr.transform('"foo" cat', "").should be == 'foo'
-    end
-  end
-end
+require 'spec_helper'
+require 'ciphr'
+
+describe Ciphr do
+  describe :transform do
+    it "works for some simple test cases" do
+        Ciphr.transform("md5 hex","").should be == "d41d8cd98f00b204e9800998ecf8427e"
+        Ciphr.transform("b64 ~b64","foobar").should be == "foobar"
+        Ciphr.transform("b2 b16 ~b16 ~b2","foobar").should be == "foobar"
+        Ciphr.transform('"foobar"',"").should be == "foobar"
+        Ciphr.transform('=ABBB b64',"").should be == "ABBB"        
+        Ciphr.transform('0x41',"").should be == "A"
+        Ciphr.transform('0b01000001',"").should be == "A"
+        Ciphr.transform('0x43 xor[0x01]',"").should be == "B"
+        Ciphr.transform('0x4343 xor[0x01]',"").should be == "BB"
+        Ciphr.transform('0x01 xor[0x4343]',"").should be == "BB"
+        Ciphr.transform('0x00 url', "").should be == '%00'
+        Ciphr.transform('"foo" cat', "").should be == 'foo'
+    end
+  end
+end

data/spec/functions_spec.rb

@@ -1,31 +1,31 @@
-require 'spec_helper'
-require 'ciphr'
-
-describe Ciphr::FunctionRegistry do
-  describe :setup do
-    it "sets up the specified functions" do
-        Ciphr::FunctionRegistry.global.setup([Ciphr::Functions::Base::Base2, Ciphr::Functions::Simple::Cat])
-        Ciphr::FunctionRegistry.global.functions.should == 
-            [
-                [Ciphr::Functions::Base::Base2, [[["b2", "base2", "bin", "binary"], {}]]], 
-                [Ciphr::Functions::Simple::Cat, [[["cat", "catenate"], {}]]]
-            ]
-        Ciphr::FunctionRegistry.global.function_aliases.should == 
-            {
-                "b2"=>[Ciphr::Functions::Base::Base2, {}], 
-                "base2"=>[Ciphr::Functions::Base::Base2, {}], 
-                "bin"=>[Ciphr::Functions::Base::Base2, {}], 
-                "binary"=>[Ciphr::Functions::Base::Base2, {}],                 
-                "cat"=>[Ciphr::Functions::Simple::Cat, {}], 
-                "catenate"=>[Ciphr::Functions::Simple::Cat, {}]
-            }
-    end
-    it "sets up the automatically registered functions" do
-        Ciphr::FunctionRegistry.global.setup
-        Ciphr::FunctionRegistry.global.functions.should include(
-            [Ciphr::Functions::Base::Base2, [[["b2", "base2","bin","binary"], {}]]])
-        Ciphr::FunctionRegistry.global.functions.should include( 
-            [Ciphr::Functions::Simple::Cat, [[["cat", "catenate"], {}]]])
-    end
-  end
-end
+require 'spec_helper'
+require 'ciphr'
+
+describe Ciphr::FunctionRegistry do
+  describe :setup do
+    it "sets up the specified functions" do
+        Ciphr::FunctionRegistry.global.setup([Ciphr::Functions::Base::Base2, Ciphr::Functions::Simple::Cat])
+        Ciphr::FunctionRegistry.global.functions.should == 
+            [
+                [Ciphr::Functions::Base::Base2, [[["b2", "base2", "bin", "binary"], {}]]], 
+                [Ciphr::Functions::Simple::Cat, [[["cat", "catenate"], {}]]]
+            ]
+        Ciphr::FunctionRegistry.global.function_aliases.should == 
+            {
+                "b2"=>[Ciphr::Functions::Base::Base2, {}], 
+                "base2"=>[Ciphr::Functions::Base::Base2, {}], 
+                "bin"=>[Ciphr::Functions::Base::Base2, {}], 
+                "binary"=>[Ciphr::Functions::Base::Base2, {}],                 
+                "cat"=>[Ciphr::Functions::Simple::Cat, {}], 
+                "catenate"=>[Ciphr::Functions::Simple::Cat, {}]
+            }
+    end
+    it "sets up the automatically registered functions" do
+        Ciphr::FunctionRegistry.global.setup
+        Ciphr::FunctionRegistry.global.functions.should include(
+            [Ciphr::Functions::Base::Base2, [[["b2", "base2","bin","binary"], {}]]])
+        Ciphr::FunctionRegistry.global.functions.should include( 
+            [Ciphr::Functions::Simple::Cat, [[["cat", "catenate"], {}]]])
+    end
+  end
+end

data/spec/randomizer_spec.rb

@@ -1,55 +1,55 @@
-require 'spec_helper'
-require 'ciphr'
-
-# considerations:
-# invertable
-# deterministic
-# padded
-# zero-input
-
-describe Ciphr::Functions do
-  r = Random.new(0) #deterministic
-  tests = [""] + (1..50).map do |i|
-    mag = r.rand(4)+1
-    len = r.rand(10**mag)
-    #len = (0.00001*r.rand(100000)**1.7).floor
-    #$stderr.puts len
-    r.bytes(len)
-  end
-
-  # temporarily disable randomization
-  tests = [""," ", "\x00", "\x00 A"]
-  
-  Ciphr::FunctionRegistry.global.setup
-  #TODO: run shorter/smaller tests first
-  
-  #TODO: decompose property tests into small, composable tests
-  functions = Ciphr::FunctionRegistry.global.functions
-  functions.find_all{|f| f[0].params.size == 1}.each do |f|
-    f[1].each do |v|
-      tests.each do |t|
-        it "#{v[0][0]} #{t.inspect}" do
-          result = Ciphr.transform(v[0][0],t)
-          if f[0] != Ciphr::Functions::Simple::Cat && t != ""
-            expect(result).not_to eq(t)
-          end
-          if f[0].invertable? && t != ""
-            inv = Ciphr.transform("~" + v[0][0],result)
-            #FIXME: need to enforce consistent encoding
-            inv,t = [inv,t].map{|s| s.force_encoding('binary')}
-            case f[0].aligned # FIXME: this is horrible
-            when :left
-              expect(inv).to start_with(t)
-            when :right
-              expect(t).to end_with(inv) # FIXME: horribly backwards
-            else
-              expect(inv).to eq(t)
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-
+require 'spec_helper'
+require 'ciphr'
+
+# considerations:
+# invertable
+# deterministic
+# padded
+# zero-input
+
+describe Ciphr::Functions do
+  r = Random.new(0) #deterministic
+  tests = [""] + (1..50).map do |i|
+    mag = r.rand(4)+1
+    len = r.rand(10**mag)
+    #len = (0.00001*r.rand(100000)**1.7).floor
+    #$stderr.puts len
+    r.bytes(len)
+  end
+
+  # temporarily disable randomization
+  tests = [""," ", "\x00", "\x00 A"] + tests
+  
+  Ciphr::FunctionRegistry.global.setup
+  #TODO: run shorter/smaller tests first
+  
+  #TODO: decompose property tests into small, composable tests
+  functions = Ciphr::FunctionRegistry.global.functions
+  functions.find_all{|f| f[0].params.size == 1}.each do |f|
+    f[1].each do |v|
+      tests.each do |t|
+        it "#{v[0][0]} #{t.inspect}" do
+          result = Ciphr.transform(v[0][0],t)
+          if f[0] != Ciphr::Functions::Simple::Cat && f[0] != Ciphr::Functions::Ascii::Rot13 && t != ""
+            expect(result).not_to eq(t)
+          end
+          if f[0].invertable? && t != ""
+            inv = Ciphr.transform("~" + v[0][0],result)
+            #FIXME: need to enforce consistent encoding
+            inv,t = [inv,t].map{|s| s.force_encoding('binary')}
+            case f[0].aligned # FIXME: this is horrible
+            when :left
+              expect(inv).to start_with(t)
+            when :right
+              expect(t).to end_with(inv) # FIXME: horribly backwards
+            else
+              expect(inv).to eq(t)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-#require 'coveralls'
-#require "codeclimate-test-reporter"
-#Coveralls.wear!
-#CodeClimate::TestReporter.start
+#require 'coveralls'
+#require "codeclimate-test-reporter"
+#Coveralls.wear!
+#CodeClimate::TestReporter.start

data/spec/stream_spec.rb

@@ -1,38 +1,38 @@
-require 'spec_helper'
-require 'ciphr'
-
-describe Ciphr::Stream do
-  describe :read do
-    it "returns nil after proc does" do
-      s = Ciphr::Stream.new Proc.new { nil }
-      s.read(1).should be == nil
-    end
-
-    it "buffers and returns data as requested" do
-      fills = ["abc", "def", "ghi"]
-      s = Ciphr::Stream.new Proc.new { fills.shift }
-      s.read(1).should be == "a"
-      s.read(3).should be == "bcd"
-      s.read(1).should be == "e"
-      s.read(2).should be == "fg"
-      s.read(4).should be == "hi"
-      s.read(1).should be == nil
-    end
-
-    it "can prepend data and read it back out" do
-      fills = ["abc", "def", "ghi"]
-      s = Ciphr::Stream.new Proc.new { fills.shift }
-      s.read(1).should be == "a"
-      s.read(3).should be == "bcd"
-      s.prepend("cd")
-      s.read(1).should be == "c"
-      s.read(1).should be == "d"
-      s.read(1).should be == "e"
-      s.prepend("cde")
-      s.read(3).should be == "cde"
-      s.read(2).should be == "fg"
-      s.read(4).should be == "hi"
-      s.read(1).should be == nil
-    end
-  end
-end
+require 'spec_helper'
+require 'ciphr'
+
+describe Ciphr::Stream do
+  describe :read do
+    it "returns nil after proc does" do
+      s = Ciphr::Stream.new Proc.new { nil }
+      s.read(1).should be == nil
+    end
+
+    it "buffers and returns data as requested" do
+      fills = ["abc", "def", "ghi"]
+      s = Ciphr::Stream.new Proc.new { fills.shift }
+      s.read(1).should be == "a"
+      s.read(3).should be == "bcd"
+      s.read(1).should be == "e"
+      s.read(2).should be == "fg"
+      s.read(4).should be == "hi"
+      s.read(1).should be == nil
+    end
+
+    it "can prepend data and read it back out" do
+      fills = ["abc", "def", "ghi"]
+      s = Ciphr::Stream.new Proc.new { fills.shift }
+      s.read(1).should be == "a"
+      s.read(3).should be == "bcd"
+      s.prepend("cd")
+      s.read(1).should be == "c"
+      s.read(1).should be == "d"
+      s.read(1).should be == "e"
+      s.prepend("cde")
+      s.read(3).should be == "cde"
+      s.read(2).should be == "fg"
+      s.read(4).should be == "hi"
+      s.read(1).should be == nil
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ciphr
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Chris Frohoff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-12 00:00:00.000000000 Z
+date: 2017-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,7 @@ files:
 - lib/ciphr.rb
 - lib/ciphr/function_registry.rb
 - lib/ciphr/functions.rb
+- lib/ciphr/functions/ascii.rb
 - lib/ciphr/functions/base_radix.rb
 - lib/ciphr/functions/bitwise.rb
 - lib/ciphr/functions/crypto.rb
@@ -133,8 +134,7 @@ files:
 - lib/ciphr/parser.rb
 - lib/ciphr/stream.rb
 - lib/ciphr/version.rb
-- pkg/ciphr-0.0.1.gem
-- pkg/ciphr-0.0.2.gem
+- pkg/ciphr-0.0.3.gem
 - spec/ciphr_spec.rb
 - spec/functions_spec.rb
 - spec/randomizer_spec.rb
@@ -170,7 +170,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: a CLI tool for performing and composing encoding, decoding, encryption, decryption,
@@ -182,4 +182,3 @@ test_files:
 - spec/randomizer_spec.rb
 - spec/spec_helper.rb
 - spec/stream_spec.rb
-has_rdoc: